Re-implementation of Queue

src/_DataStructures_/LinkedList/index.js

@@ -8,32 +8,44 @@ class Node {
 class LinkedList {
   constructor() {
     this.head = null;
+    this.tail = null;
+    this.size = 0;
   }
 
   addAtBeginning(element) {
     this.head = new Node(element, this.head);
+    if (!this.tail) {
+      this.tail = this.head;
+    }
+    this.size += 1;
+    return this.head;
   }
 
   addAtEnd(element) {
     const node = new Node(element, null);
+    this.size += 1;
 
     if (!this.head) {
       this.head = node;
-    } else {
-      let address = this.head;
-      while (address.next) {
-        address = address.next;
-      }
-      address.next = node;
+      this.tail = node;
+      return node;
     }
+    this.tail.next = node;
+    this.tail = node;
+    return node;
   }
 
   removeFromBeginning() {
     if (!this.head) {
       return null;
     }
+    if (this.head.next === null) {
+      this.tail = this.head;
+    }
     const node = this.head;
     this.head = this.head.next;
+    this.size -= 1;
+    node.next = null;
     return node;
   }
 
@@ -47,8 +59,11 @@ class LinkedList {
       address = address.next;
     }
 
-    const node = address.next;
-    address.next = null;
+    this.tail = address;
+
+    const node = this.tail.next;
+    this.tail.next = null;
+    this.size -= 1;
     return node;
   }
 
@@ -63,11 +78,7 @@ class LinkedList {
     if (!this.head) {
       return null;
     }
-    let address = this.head;
-    while (address.next) {
-      address = address.next;
-    }
-    return address;
+    return this.tail;
   }
 
   getAt(index) {
@@ -104,8 +115,10 @@ class LinkedList {
       count -= 1;
     }
 
-    previous.next = new Node(element, previous.next);
-    return null;
+    const node = new Node(element, previous.next);
+    previous.next = node;
+    this.size += 1;
+    return node;
   }
 
   removeAt(index) {
@@ -129,21 +142,19 @@ class LinkedList {
 
     const node = address;
     previous.next = address.next.next;
+    this.size -= 1;
+    node.next = null;
     return node;
   }
 
   length() {
-    let address = this.head;
-    let count = 0;
-    while (address) {
-      count += 1;
-      address = address.next;
-    }
-    return count;
+    return this.size;
   }
 
   delete() {
     this.head = null;
+    this.tail = this.head;
+    this.size = 0;
   }
 }
 

src/_DataStructures_/Queue/Queue.test.js

@@ -12,23 +12,24 @@ describe('Data Structure : Queue', () => {
       queue = new Queue();
     });
 
-    it('Should add() element to a queue', () => {
-      queue.add(5);
-      expect(queue.data).toEqual([5]);
+    it('Should add element to a queue', () => {
+      queue.enqueue(5);
+      expect(queue.peek()).toEqual(5);
     });
 
-    it('Should remove() an element from the queue', () => {
-      queue.add(2);
-      queue.add(3);
+    it('Should dequeue() an element from the queue', () => {
+      queue.enqueue(2);
+      queue.enqueue(3);
 
-      expect(queue.remove()).toEqual(2);
-      expect(queue.data).toEqual([3]);
+      expect(queue.dequeue()).toEqual(2);
+      expect(queue.peek()).toEqual(3);
+      expect(queue.length()).toEqual(1);
     });
 
     describe('peek()', () => {
       beforeEach(() => {
-        queue.add(2);
-        queue.add(5);
+        queue.enqueue(2);
+        queue.enqueue(5);
       });
 
       it('Should return the elemet to be removed using peek()', () => {
@@ -37,21 +38,21 @@ describe('Data Structure : Queue', () => {
 
       it('Should not remove the element', () => {
         expect(queue.peek()).toEqual(2);
-        expect(queue.remove()).toEqual(2);
+        expect(queue.dequeue()).toEqual(2);
       });
     });
 
     it('Should maintain the order of elements', () => {
       // first in first out
-      queue.add(2);
-      queue.add(1);
-      queue.add(4);
-      queue.add(3);
-
-      expect(queue.remove()).toEqual(2);
-      expect(queue.remove()).toEqual(1);
-      expect(queue.remove()).toEqual(4);
-      expect(queue.remove()).toEqual(3);
+      queue.enqueue(2);
+      queue.enqueue(1);
+      queue.enqueue(4);
+      queue.enqueue(3);
+
+      expect(queue.dequeue()).toEqual(2);
+      expect(queue.dequeue()).toEqual(1);
+      expect(queue.dequeue()).toEqual(4);
+      expect(queue.dequeue()).toEqual(3);
     });
   });
 });

src/_DataStructures_/Queue/QueueUsingArray.js

@@ -0,0 +1,20 @@
+class Queue {
+  constructor() {
+    this.data = [];
+  }
+
+  add(element) {
+    // add element to the start of the data
+    return this.data.unshift(element);
+  }
+
+  peek() {
+    return this.data[this.data.length - 1];
+  }
+
+  remove() {
+    return this.data.pop();
+  }
+}
+
+module.exports = Queue;

src/_DataStructures_/Queue/index.js

@@ -1,20 +1,57 @@
-class Queue {
+const { LinkedList: SinglyLinkedLists } = require('../LinkedList');
+
+class Queue extends SinglyLinkedLists {
   constructor() {
-    this.data = [];
+    super();
+    this.NotAllowed = 'Not Allowed';
+  }
+
+  enqueue(data) {
+    return this.addAtEnd(data);
   }
 
-  add(element) {
-    // add element to the start of the data
-    return this.data.unshift(element);
+  dequeue() {
+    const node = this.removeFromBeginning();
+    return node ? node.data : node;
   }
 
   peek() {
-    return this.data[this.data.length - 1];
+    const node = this.getFirst();
+    return node ? node.data : node;
+  }
+
+  length() {
+    return this.size;
+  }
+
+  destroy() {
+    this.delete();
+  }
+
+  /** Override and throw error for other LL methods */
+  addAtBeginning() {
+    throw new Error(this.NotAllowed);
+  }
+
+  addAt() {
+    throw new Error(this.NotAllowed);
+  }
+
+  removeFromEnd() {
+    throw new Error(this.NotAllowed);
+  }
+
+  getLast() {
+    throw new Error(this.NotAllowed);
+  }
+
+  getAt() {
+    throw new Error(this.NotAllowed);
   }
 
-  remove() {
-    return this.data.pop();
+  removeAt() {
+    throw new Error(this.NotAllowed);
   }
 }
 
-module.exports = Queue;
+module.exports = Queue;

src/_DataStructures_/Queue/weave/index.js

@@ -4,12 +4,12 @@ function weaveQueues(first, second) {
   const weaved = new Queue();
 
   while (first.peek() || second.peek()) {
-    if (first.peek() !== undefined) {
-      weaved.add(first.remove());
+    if (first.peek()) {
+      weaved.enqueue(first.dequeue());
     }
 
-    if (second.peek() !== undefined) {
-      weaved.add(second.remove());
+    if (second.peek()) {
+      weaved.enqueue(second.dequeue());
     }
   }
   return weaved;

src/_DataStructures_/Queue/weave/weave.test.js

@@ -10,18 +10,18 @@ describe('Weave two queues using weaveQueues()', () => {
     const q1 = new Queue();
     const q2 = new Queue();
 
-    q1.add('Hello');
-    q2.add(1);
-    q1.add('World');
-    q2.add(2);
-    q2.add(3);
+    q1.enqueue('Hello');
+    q2.enqueue(1);
+    q1.enqueue('World');
+    q2.enqueue(2);
+    q2.enqueue(3);
 
     const q3 = weaveQueues(q1, q2);
 
-    expect(q3.remove()).toEqual('Hello');
-    expect(q3.remove()).toEqual(1);
-    expect(q3.remove()).toEqual('World');
-    expect(q3.remove()).toEqual(2);
-    expect(q3.remove()).toEqual(3);
+    expect(q3.dequeue()).toEqual('Hello');
+    expect(q3.dequeue()).toEqual(1);
+    expect(q3.dequeue()).toEqual('World');
+    expect(q3.dequeue()).toEqual(2);
+    expect(q3.dequeue()).toEqual(3);
   });
 });