Merge Deque changes to new structure and resolve conflicts

Author: 4ndrelim

src/main/java/algorithms/patternFinding/KMP.java

@@ -17,8 +17,8 @@
  *                 there is no prefix ending before its index, 0, that can be matched with.
  *      Read:          ^   ^ 'B' and 'C' cannot be matched with any prefix which are just 'A' and 'AB' respectively.
  *      Read:                  ^ Can be matched with an earlier 'A'. So we store 1.
- *                             Prefix is the substring from idx 0 to 1 (exclusive).
- *                             Which can also be interpreted as the index of the next character to match against!
+ *                             Prefix is the substring from idx 0 to 1 (exclusive). Note consider prefix from 0-indexed.
+ *                             Realise 1 can also be interpreted as the index of the next character to match against!
  *      Read:                      ^   ^ Similarly, continue matching
  *      Read:                               ^  ^ No matches, so 0
  *      Read:                                      ^   ^   ^   ^   ^   ^ Match with prefix until position 6!
@@ -34,12 +34,13 @@
  * String : ABABCABABABAB
  *
  *          A  B  A  B  C  A  B  A  B  A  B  A  B
- *   Read:  ^    to  ^ Continue matching until with Pattern[0:4]
- *   Read:        ^ try ^ Unable to match Pattern[4]. But since last two characters form a sub-pattern
- *   Read:              try matching until Pattern[0:3] by checking if Pattern[2] == 'C'.
- *   Read:              Turns out no. No previously identified sub-pattern with 'C'. Restart.
+ *   Read:  ^    to  ^ Continue matching where possible, leading to Pattern[0:4] matched.
+ *          unable to match Pattern[4]. But notice that last two characters of String[0:4]
+ *          form a sub-pattern with Pattern[0:2] Maybe Pattern[2] == 'C' and we can 're-use' Pattern[0:2]
+ *   Read:        ^ try ^ by checking if Pattern[2] == 'C'
+ *   Read:              Turns out no. No previously identified sub-pattern with 'C'. Restart matching Pattern.
  *   Read:                 ^      to      ^ Found complete match! But rather than restart, notice that last 4 characters
- *   Read:                 form a prefix sub-pattern of Pattern, so,
+ *   Read:                 form a prefix sub-pattern of Pattern, which is Pattern[0:4] = "ABAB", so,
  *   Read:                       ^               ^ Start matching from Pattern[4] and finally Pattern[5]
  */
 public class KMP {
@@ -53,6 +54,7 @@ private static int[] getPrefixIndices(String pattern) {
         int len = pattern.length();
         int[] prefixIndices = new int[len + 1];
         prefixIndices[0] = -1;
+        prefixIndices[1] = 0; // 1st character has no prefix to match with
 
         int currPrefixMatched = 0; // num of chars of prefix pattern currently matched
         int pos = 2; // Starting from the 2nd character, recall 1-indexed

src/main/java/dataStructures/queue/Deque.java

@@ -0,0 +1,170 @@
+package dataStructures.queue;
+
+public class Deque<T> {
+
+    private Node<T> first;
+    private Node<T> last;
+    private int size;
+
+    /**
+     * Constructor for empty Deque.
+     */
+    public Deque() {
+        this.size = 0;
+        this.first = this.last = null; // implemented with double-linked list
+    }
+
+    /**
+     * Check if deque is empty.
+     *
+     * @return True if empty.
+     */
+    public boolean isEmpty() {
+        return this.size == 0;
+    }
+
+    /**
+     * Get size of deque.
+     *
+     * @return Size of the deque.
+     */
+    public int getSize() {
+        return this.size;
+    }
+
+    /**
+     * Add element into the back of the deque.
+     *
+     * @param val Element to be added.
+     */
+    public void addElement(T val) {
+        Node<T> newNode = new Node<>(val);
+        if (this.isEmpty()) {
+            this.last = this.first = newNode;
+            size++;
+            return;
+        }
+        Node<T> temp = this.last;
+        temp.next = newNode;
+        newNode.prev = temp;
+        this.last = newNode;
+        this.size++;
+    }
+
+    /**
+     * Add a element into the front of the deque.
+     * @param val Element to be added.
+     */
+    public void addFirst(T val) {
+        Node<T> newNode = new Node<>(val);
+        if (this.isEmpty()) {
+            this.last = this.first = newNode;
+            size++;
+            return;
+        }
+        Node<T> temp = this.first;
+        temp.prev = newNode;
+        newNode.next = temp;
+        this.first = newNode;
+        size++;
+    }
+
+    /**
+     * Peek the first element of the deque.
+     *
+     * @return The value in the first node of the deque.
+     */
+    public T peekFirst() {
+        if (this.isEmpty()) {
+            return null;
+        }
+        return first.val;
+    }
+
+    /**
+     * Peek the last element of the deque.
+     *
+     * @return The value in the last node of the deque.
+     */
+    public T peekLast() {
+        if (this.isEmpty()) {
+            return null;
+        }
+        return last.val;
+    }
+
+    /**
+     * Removes and retrieves the first element of the deque.
+     *
+     * @return The value in the first node of the deque.
+     */
+    public T pollFirst() {
+        if (this.isEmpty()) {
+            return null;
+        }
+        Node<T> firstNode = this.first;
+        Node<T> newFirstNode = this.first.next;
+        if (newFirstNode != null) {
+            newFirstNode.prev = null;
+        }
+        this.first = newFirstNode;
+        firstNode.next = null;
+        this.size--;
+        return firstNode.val;
+    }
+
+    /**
+     * Removes and retrieves the last element of the deque.
+     *
+     * @return The value in the last node of the deque.
+     */
+    public T pollLast() {
+        if (this.isEmpty()) {
+            return null;
+        }
+        Node<T> lastNode = this.last;
+        Node<T> newLastNode = lastNode.prev;
+        if (newLastNode != null) {
+            newLastNode.next = null;
+        }
+        lastNode.prev = null;
+        this.last = newLastNode;
+        this.size--;
+        return lastNode.val;
+    }
+
+    /**
+     * Converts Deque into String iteratively.
+     *
+     * @return String representation of elements in the deque.
+     */
+    @Override
+    public String toString() {
+        if (this.isEmpty()) {
+            return "[]";
+        }
+        String ret = "[";
+        Node<T> temp = this.first;
+        while (temp != null) {
+            ret += " " + temp.toString() + " ";
+            temp = temp.next;
+        }
+        return ret + "]";
+    }
+
+    private static class Node<T> {
+        private T val;
+        Node<T> next;
+        Node<T> prev;
+
+        public Node(T val) {
+            this.val = val;
+            this.next = this.prev = null;
+        }
+
+        @Override
+        public String toString() {
+            return this.val.toString();
+        }
+    }
+}

src/main/java/dataStructures/queue/MonotonicQueue.java

@@ -4,7 +4,7 @@
 import java.util.ArrayDeque;
 
 /**
- * Implementation of a non-increasing monotonic queue for certain (but common) use case:
+ * Implementation of a non-increasing (decreasing) monotonic queue for certain (but common) use case:
  * When larger objects pushed to the queue are able to replace and represent smaller objects that come before it.
  * Callable methods are:
  * isEmpty()
@@ -20,8 +20,9 @@
  * 4       2   [1, 2] #2->1            [5, 3, 2] 2 kick out 1 #2->3
  * 5       4   [1, 2, 4] #4->2         [5,4] 4 kick out 2, 3 #4->2
  */
+
 public class MonotonicQueue<T extends Comparable<T>> {
-  private Deque<Pair<T>> dq = new ArrayDeque<>(); // or LinkedList
+  private Deque<T> dq = new ArrayDeque<>(); // or LinkedList
 
   /**
    * Checks if queue is empty.
@@ -37,12 +38,10 @@ public boolean isEmpty() {
    */
   public void push(T obj) {
     Integer count = 0;
-    while (!dq.isEmpty() && obj.compareTo(dq.peekLast().value) >= 0) {
-      Pair<T> popped = dq.pollLast();
-      // accumulate count of objects that were popped to maintain the non-increasing property
-      count += 1 + popped.countDeleted; 
+    while (!dq.isEmpty() && obj.compareTo(dq.peekLast()) > 0) {
+      dq.pollLast(); // Removes elements that do not conform the non-increasing sequence.
     }
-    dq.offerLast(new Pair<T>(obj, count));
+    dq.offerLast(obj);
   }
 
   /**
@@ -53,7 +52,7 @@ public T max() {
     if (isEmpty()) {
       return null;
     }
-    return dq.peek().value;
+    return dq.peek();
   }
 
   /**
@@ -64,26 +63,6 @@ public T pop() {
     if (dq.isEmpty()) {
       return null;
     }
-    Pair<T> node = dq.peek();
-    if (node.countDeleted > 0) {
-      node.countDeleted -= 1;
-      return node.value;
-    }
-    dq.poll();
-    return node.value;
-  }
-
-  /**
-   * Node class that is represented as a pair.
-   * Tracks the deleted count and the value to be wrapped.
-   */
-  private static class Pair<T> {
-    private T value;
-    private Integer countDeleted;
-
-    private Pair(T val, Integer count) {
-      this.value = val;
-      this.countDeleted = count;
-    }
+    return dq.poll(); // Returns & remove head of deque
   }
 }

src/test/java/dataStructures/queue/MonotonicQueueTest.java

@@ -0,0 +1,57 @@
+package dataStructures.queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MonotonicQueueTest {
+    @Test
+    public void testEmpty() {
+        MonotonicQueue<Integer> q = new MonotonicQueue<>();
+        Assert.assertEquals(true, q.isEmpty());
+        Assert.assertEquals(null, q.max());
+        Assert.assertEquals(null, q.pop());
+    }
+
+    @Test
+    public void testMax() {
+        MonotonicQueue<Integer> q = new MonotonicQueue<>();
+        q.push(2);
+        Assert.assertEquals("2", q.max().toString());
+        q.push(7);
+        Assert.assertEquals("7", q.max().toString());
+        q.push(1);
+        Assert.assertEquals("7", q.max().toString());
+        q.push(7);
+        Assert.assertEquals("7", q.max().toString());
+        q.push(5);
+        Assert.assertEquals("7", q.max().toString());
+        q.push(4);
+        Assert.assertEquals("7", q.max().toString());
+        q.push(3);
+        q.push(2);
+        q.push(5);
+        Assert.assertEquals("7", q.max().toString());
+    }
+
+    @Test
+    public void testPop() {
+        MonotonicQueue<Integer> q = new MonotonicQueue<>();
+        q.push(2);
+        q.push(7);
+        q.push(1);
+        q.push(7);
+        q.push(5);
+        q.push(4);
+        q.push(3);
+        q.push(2);
+        q.push(5);
+        q.push(2);
+
+        Assert.assertEquals("7", q.pop().toString());
+        Assert.assertEquals("7", q.pop().toString());
+        Assert.assertEquals("5", q.pop().toString());
+        q.pop();
+        Assert.assertEquals("2", q.pop().toString());
+        Assert.assertEquals(null, q.pop());
+    }
+}