linear data structure fixes

Author: amejiarosario

src/data-structures/linked-lists/linked-list.js

@@ -17,20 +17,20 @@ class LinkedList {
    * @param {any} value
    */
   addFirst(value) {
-    const node = new Node(value);
+    const newNode = new Node(value);
 
-    node.next = this.first;
+    newNode.next = this.first;
 
     if (this.first) {
-      this.first.previous = node;
+      this.first.previous = newNode;
     } else {
-      this.last = node;
+      this.last = newNode;
     }
 
-    this.first = node; // update head
+    this.first = newNode; // update head
     this.size += 1;
 
-    return node;
+    return newNode;
   }
 
   /**
@@ -89,53 +89,6 @@ class LinkedList {
     return undefined; // out of bound index
   }
 
-  /**
-   * Removes element from the start of the list (head/root). similar Array.shift
-   * Runtime: O(1)
-   */
-  removeFirst() {
-    const first = this.first;
-
-    if (first) {
-      this.first = first.next;
-      if (this.first) {
-        this.first.previous = null;
-      }
-
-      this.size--;
-
-      return first.value;
-    }
-    this.last = null;
-  }
-
-  /**
-   * Removes element to the end of the list
-   * similar to Array.pop
-   * Using the `last.previous` we can reduce the runtime from O(n) to O(1)
-   * Runtime: O(1)
-   */
-  removeLast() {
-    let current = this.first;
-    let target;
-
-    if (current && current.next) {
-      current = this.last.previous;
-      this.last = current;
-      target = current.next;
-      current.next = null;
-    } else {
-      this.first = null;
-      this.last = null;
-      target = current;
-    }
-
-    if (target) {
-      this.size--;
-      return target.value;
-    }
-  }
-
   /**
    * Search by value. It finds first occurrence  of
    * the element matching the value.
@@ -185,26 +138,66 @@ class LinkedList {
   }
 
   /**
-   * Remove the nth element from the list. Starting with 0
-   * Returns value if found or undefined if it was not found
-   * Runtime: O(n)
-   * @param {any} index
+   * Removes element from the start of the list (head/root).
+   * Similar to Array.shift
+   * Runtime: O(1)
+   * @returns {any} the first element's value which was removed.
    */
-  remove(index = 0) {
-    if (index === 0) {
-      return this.removeFirst();
+  removeFirst() {
+    const head = this.first;
+
+    if (head) {
+      this.first = head.next;
+      if (this.first) {
+        this.first.previous = null;
+      }
+      this.size -= 1;
+    } else {
+      this.last = null;
     }
+    return head && head.value;
+  }
 
-    for (let current = this.first, i = 0; current; i++, current = current.next) {
-      if (i === index) {
-        if (!current.next) { // if it doesn't have next it means that it is the last
-          return this.removeLast();
-        }
-        current.previous = current.next;
-        this.size--;
-        return current.value;
+  /**
+   * Removes element to the end of the list. Similar to Array.pop
+   * Using the `last.previous` we can reduce the runtime from O(n) to O(1)
+   * Runtime: O(1)
+   * @returns {value} the last element's value which was removed
+   */
+  removeLast() {
+    const tail = this.last;
+
+    if (tail) {
+      this.last = tail.previous;
+      if (this.last) {
+        this.last.next = null;
+      } else {
+        this.first = null;
       }
+      this.size -= 1;
     }
+    return tail && tail.value;
+  }
+
+  /**
+   * Removes the element at the specified position in this list.
+   * Runtime: O(n)
+   * @param {any} position
+   * @returns {any} the element's value at the specified position that was removed.
+   */
+  remove(position = 0) {
+    const current = this.get(position);
+
+    if (position === 0) {
+      this.removeFirst();
+    } else if (position === this.size) {
+      this.removeLast();
+    } else if (current) {
+      current.previous = current.next;
+      this.size -= 1;
+    }
+
+    return current && current.value;
   }
 }
 

src/data-structures/linked-lists/linked-list.spec.js

@@ -40,8 +40,7 @@ describe('LinkedList', () => {
       expect(linkedList.last.value).toBe('b');
 
       expect(linkedList.removeFirst()).toBe('b');
-      expect(linkedList.removeFirst()).toBe(undefined);
-      // expect(linkedList.removeFirst()).toBe(undefined);
+      expect(linkedList.removeFirst()).toBe(null);
 
       expect(linkedList.first).toBe(null);
       expect(linkedList.last).toBe(null);
@@ -73,17 +72,26 @@ describe('LinkedList', () => {
     });
 
     it('should remove first item', () => {
+      expect(linkedList.size).toBe(3);
+      expect(linkedList.first.value).toBe('a');
+      expect(linkedList.last.value).toBe('c');
+
       expect(linkedList.removeLast()).toBe('c');
       expect(linkedList.last.value).toBe('b');
+      expect(linkedList.first.value).toBe('a');
+      expect(linkedList.size).toBe(2);
 
       expect(linkedList.removeLast()).toBe('b');
       expect(linkedList.last.value).toBe('a');
       expect(linkedList.first.value).toBe('a');
       expect(linkedList.first.next).toBe(null);
+      expect(linkedList.size).toBe(1);
 
       expect(linkedList.removeLast()).toBe('a');
-      expect(linkedList.removeLast()).toBe(undefined);
-      // expect(linkedList.removeLast()).toBe(undefined);
+      expect(linkedList.first).toBe(null);
+      expect(linkedList.last).toBe(null);
+      expect(linkedList.removeLast()).toBe(null);
+      expect(linkedList.size).toBe(0);
 
       expect(linkedList.first).toBe(null);
       expect(linkedList.last).toBe(null);
@@ -135,7 +143,9 @@ describe('LinkedList', () => {
 
       it('should update size, last and first', () => {
         expect(linkedList.remove(0)).toBe(0);
+        expect(linkedList.size).toBe(1);
         expect(linkedList.remove(0)).toBe('found');
+        expect(linkedList.size).toBe(0);
         expect(linkedList.remove(0)).toBe(undefined);
         expect(linkedList.size).toBe(0);
         expect(linkedList.first).toBe(null);
@@ -271,7 +281,7 @@ describe('LinkedList', () => {
         expect(linkedList.removeLast()).toBe('c');
         expect(linkedList.pop()).toBe('b');
         expect(linkedList.remove()).toBe('a');
-        expect(linkedList.shift()).toBe(undefined);
+        expect(linkedList.shift()).toBe(null);
         linkedList.removeLast();
         expect(linkedList.size).toBe(0);
       });

src/data-structures/queues/queue.js

@@ -5,43 +5,44 @@ const LinkedList = require('../linked-lists/linked-list');
  */
 class Queue {
   constructor() {
-    this.input = new LinkedList();
+    this.items = new LinkedList();
   }
 
   /**
    * Add element to the queue
    * Runtime: O(1)
-   * @param {any} element
+   * @param {any} item
    */
-  add(element) {
-    this.input.addFirst(element);
+  enqueue(item) {
+    this.items.addLast(item);
   }
 
   /**
    * Remove element from the queue
    * Runtime: O(1)
    */
-  remove() {
-    return this.input.removeLast();
+  dequeue() {
+    return this.items.removeFirst();
   }
 
   /**
    * Size of the queue
    */
   get size() {
-    return this.input.size;
+    return this.items.size;
   }
 
   /**
    * Return true if is empty false otherwise true
    */
   isEmpty() {
-    return !this.input.size;
+    return !this.items.size;
   }
 }
 
 // Aliases
-Queue.prototype.enqueue = Queue.prototype.add;
-Queue.prototype.dequeue = Queue.prototype.remove;
+Queue.prototype.add = Queue.prototype.enqueue;
+Queue.prototype.remove = Queue.prototype.dequeue;
 
 module.exports = Queue;
+

src/data-structures/queues/queue.spec.js

@@ -31,7 +31,7 @@ describe('Queue', () => {
       queue.add('c');
       expect(queue.remove()).toEqual('b');
       expect(queue.remove()).toEqual('c');
-      expect(queue.remove()).toBe(undefined);
+      expect(queue.remove()).toBe(null);
     });
   });
 

src/data-structures/stacks/stack.js

@@ -1,43 +1,45 @@
 const LinkedList = require('../linked-lists/linked-list');
 
 /**
- * Data structure that adds and remove elements in a last-in, first-out (LIFO) fashion
+ * Data structure that adds and remove elements in a first-in, first-out (FIFO) fashion
  */
 class Stack {
   constructor() {
-    this.input = new LinkedList();
+    this.items = new LinkedList();
   }
 
   /**
-   * Add element into the stack
+   * Add element into the stack.
+   * Similar to Array.push
    * Runtime: O(1)
-   * @param {any} element
+   * @param {any} item
    */
-  add(element) {
-    this.input.addLast(element);
+  add(item) {
+    this.items.addLast(item);
     return this;
   }
 
   /**
-   * Remove element from the stack
+   * Remove element from the stack.
+   * Similar to Array.pop
    * Runtime: O(1)
    */
   remove() {
-    return this.input.removeLast();
+    return this.items.removeLast();
   }
 
   /**
    * Size of the queue
    */
   get size() {
-    return this.input.size;
+    return this.items.size;
   }
 
   /**
    * Return true if is empty false otherwise true
    */
   isEmpty() {
-    return !this.input.size;
+    return !this.items.size;
   }
 }
 

src/data-structures/stacks/stack.spec.js

@@ -24,7 +24,7 @@ describe('Stack', () => {
     it('should get last element entered', () => {
       expect(stack.pop()).toEqual('b');
       expect(stack.pop()).toEqual('a');
-      expect(stack.pop()).toEqual(undefined);
+      expect(stack.pop()).toEqual(null);
     });
   });