Merge pull request #37 from yeoshuheng/deque

Deque

Author: yeoshuheng

src/dataStructures/queue/Deque.java

@@ -0,0 +1,170 @@
+package src.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;
+    }
+
+    /**
+     * 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();
+        }
+    }
+}

test/dataStructures/queue/dequeTest.java

@@ -0,0 +1,61 @@
+package test.dataStructures.queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+import src.dataStructures.queue.Deque;
+
+import java.util.Optional;
+
+public class dequeTest {
+
+    @Test
+    public void testEmpty() {
+        Deque<Integer> d = new Deque<>();
+        Assert.assertEquals(true, d.isEmpty());
+        Assert.assertEquals(0, d.getSize());
+        Assert.assertEquals(d.peekFirst(), null);
+        Assert.assertEquals(d.peekLast(), null);
+    }
+
+    @Test
+    public void testInsertion() {
+        Deque<Integer> d = new Deque<>();
+        Assert.assertEquals("[]", d.toString());
+        d.addElement(2);
+        d.addElement(3);
+        d.addFirst(1);
+        Assert.assertEquals("[ 1  2  3 ]", d.toString());
+        Assert.assertEquals(3, d.getSize());
+    }
+
+    @Test
+    public void testPeek() {
+        Deque<Integer> d = new Deque<>();
+        Assert.assertEquals(null, d.peekFirst());
+        Assert.assertEquals(null, d.peekLast());
+        d.addElement(1);
+        d.addElement(2);
+        d.addElement(3);
+        d.peekLast();
+        Assert.assertEquals(3, d.getSize());
+        Assert.assertEquals(Optional.of(1).get(), d.peekFirst());
+        Assert.assertEquals(Optional.of(3).get(), d.peekLast());
+    }
+
+    @Test
+    public void testPoll() {
+        Deque<Integer> d = new Deque<>();
+        Assert.assertEquals(null, d.pollFirst());
+        Assert.assertEquals(null, d.pollLast());
+        d.addElement(1);
+        d.addElement(2);
+        d.addElement(3);
+        Assert.assertEquals(Optional.of(1).get(), d.pollFirst());
+        Assert.assertEquals(Optional.of(3).get(), d.pollLast());
+        Assert.assertEquals(1, d.getSize());
+        Assert.assertEquals("[ 2 ]", d.toString());
+        Assert.assertEquals(Optional.of(2).get(), d.pollLast());
+        Assert.assertEquals(0, d.getSize());
+    }
+
+}