feat(linkedlist) add operation handles middle insertion

Author: amejiarosario

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

@@ -17,21 +17,20 @@ class LinkedList {
    * @param {any} value
    */
   addLast(value) {
-    const node = new Node(value);
+    const newNode = new Node(value);
 
     if(this.first) {
-      let currentNode = this.first;
-      node.previous = this.last;
-      this.last.next = node;
-      this.last = node;
+      newNode.previous = this.last;
+      this.last.next = newNode;
+      this.last = newNode;
     } else {
-      this.first = node;
-      this.last = node;
+      this.first = newNode;
+      this.last = newNode;
     }
 
     this.size++;
 
-    return node;
+    return newNode;
   }
 
   /**
@@ -122,15 +121,15 @@ 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} nth
+   * @param {any} index
    */
-  removeAt(nth) {
-    if(nth === 0) {
+  removeAt(index) {
+    if(index === 0) {
       return this.removeFirst();
     }
 
-    for (let current = this.first, index = 0; current;  index++, current = current.next) {
-      if(index === nth) {
+    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();
         }
@@ -141,10 +140,38 @@ class LinkedList {
     }
   }
 
+  /**
+   * Insert new element on the given position
+   * Returns index if it failed to insert element (index out of bounds), otherwise undefined
+   * @param {any} value new node's value
+   * @param {Number} index position to insert element
+   */
+  add(value, index = 0) {
+    if(index === 0) {
+      return this.addFirst(value);
+    }
+
+    for (let current = this.first, i = 0; i <= this.size;  i++, current = (current && current.next)) {
+      if(i === index) {
+        if(i === this.size) { // if it doesn't have next it means that it is the last
+          return this.addLast(value);
+        }
+        const newNode = new Node(value);
+        newNode.previous = current.previous;
+        newNode.next = current;
+
+        current.previous.next = newNode;
+        if(current.next) { current.next.previous = newNode; }
+        this.size++;
+        return newNode;
+      }
+    }
+  }
+
 }
 
 // Aliases
-LinkedList.prototype.add = LinkedList.prototype.push = LinkedList.prototype.addLast;
+LinkedList.prototype.push = LinkedList.prototype.addLast;
 LinkedList.prototype.remove = LinkedList.prototype.pop = LinkedList.prototype.removeLast;
 LinkedList.prototype.unshift = LinkedList.prototype.addFirst;
 LinkedList.prototype.shift = LinkedList.prototype.removeFirst;

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

@@ -131,6 +131,41 @@ describe('LinkedList', function () {
         expect(linkedList.last).toBe(null);
       });
     });
+
+    describe('#addAt', () => {
+      it('should insert at the beginning', () => {
+        const newNode = linkedList.add('first', 0);
+        expect(newNode.value).toBe('first');
+        expect(newNode.next.value).toBe(0);
+        expect(linkedList.size).toBe(3);
+        expect(linkedList.first).toBe(newNode);
+      });
+
+      it('should insert at the middle', () => {
+        const newNode = linkedList.add('middle', 1);
+        expect(newNode.value).toBe('middle');
+        expect(newNode.next.value).toBe('found');
+        expect(newNode.previous.value).toBe(0);
+        expect(linkedList.size).toBe(3);
+        expect(linkedList.first.value).toBe(0);
+      });
+
+      it('should insert at the end', () => {
+        const newNode = linkedList.add('end', 2);
+        expect(newNode.value).toBe('end');
+        expect(newNode.next).toBe(null);
+        expect(newNode.previous.value).toBe('found');
+        expect(linkedList.size).toBe(3);
+        expect(linkedList.last.value).toBe('end');
+      });
+
+      it('should not insert out of bound', () => {
+        const newNode = linkedList.add('out-of-bound', 3);
+        expect(newNode).toBe(undefined);
+        expect(linkedList.last.value).toBe('found');
+        expect(linkedList.size).toBe(2);
+      });
+    });
   });
 
   describe('Doubly Linked List and aliases', () => {
@@ -218,7 +253,7 @@ describe('LinkedList', function () {
         // a -> b -> c
         linkedList.push('b');
         linkedList.unshift('a');
-        linkedList.add('c');
+        linkedList.addLast('c');
       });
 
       it('should do nothing with previous', () => {