feat(linkedlist) searchByIndex

Author: amejiarosario

src/data-structures/arrays/array.js

@@ -1,6 +1,9 @@
+/* eslint-disable */
 const assert = require('assert');
 
-const array = [2, 5, 1, 9, 6, 7];
+
+const array = [2, 5, 1, 9, 6, 7]; // JavaScript
+array[4]; //=> 6
 
 // Insert to tail
 array.push(4); // array: [2, 5, 1, 9, 6, 7, 4]
@@ -15,6 +18,21 @@ array.unshift(0); // array: [0, 2, 5, 1, 9, 6, 7, 4, empty, 3];
 // on the position 4, delete 2 elements
 array.splice(4, 2); // array: [0, 2, 5, 1, 7, 4, empty, 3]
 
+// Inserting element sin the middle
+array.splice(1, 0, 111); // at the postion 1, delete 0 elements and insert 111
+//=> array: [2, 111, 5, 1, 9, 6, 7]
+
+// Deleting from the beginning of the array.
+array.shift(); //=> [5, 1, 9, 6, 7]
+
+// Deleting from the middle
+array.splice(2, 1); // delete 1 element at position 2
+// => array: [2, 5, 9, 6, 7]
+
+// Deleting last element from the array
+array.pop(); // => array: [2, 5, 1, 9, 6]
+
+
 
 /**
  * Search for array's element by index

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

@@ -1,7 +1,8 @@
 const Node = require('./node');
 
 /**
- * Doubly linked list that keeps track of the last and first element
+ * Doubly linked list that keeps track of
+ * the last and first element
  */
 class LinkedList {
   constructor() {
@@ -11,11 +12,35 @@ class LinkedList {
   }
 
   /**
-   * Adds element to the end of the list (tail). Similar to Array.push
-   * Using the element last reference instead of finding last, we can reduce the runtime from O(n) to O(1)
+   * Adds element to the begining of the list. Similar to Array.unshift
    * Runtime: O(1)
    * @param {any} value
    */
+  addFirst(value) {
+    const node = new Node(value);
+
+    node.next = this.first;
+
+    if (this.first) {
+      this.first.previous = node;
+    } else {
+      this.last = node;
+    }
+
+    this.first = node; // update head
+    this.size += 1;
+
+    return node;
+  }
+
+  /**
+   * Adds element to the end of the list (tail). Similar to Array.push
+   * Using the element last reference instead of navigating through the list,
+   * we can reduced from linear to a constant runtime.
+   * Runtime: O(1)
+   * @param {any} value node's value
+   * @returns {Node} newly created node
+   */
   addLast(value) {
     const newNode = new Node(value);
 
@@ -28,11 +53,45 @@ class LinkedList {
       this.last = newNode;
     }
 
-    this.size++;
+    this.size += 1;
 
     return newNode;
   }
 
+  /**
+   * Insert new element at the given position (index)
+   *
+   * @param {any} value new node's value
+   * @param {Number} position position to insert element
+   * @returns {Node} new node or 'undefined' if the index is out of bound.
+   */
+  add(value, position = 0) {
+    if (position === 0) {
+      return this.addFirst(value);
+    }
+
+    if (position === this.size) {
+      return this.addLast(value);
+    }
+
+    for (let current = this.first, index = 0;
+      index <= this.size;
+      index += 1, current = (current && current.next)) {
+      if (index === position) {
+        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 += 1;
+        return newNode;
+      }
+    }
+
+    return undefined; // out of bound index
+  }
+
   /**
    * Removes element from the start of the list (head/root). similar Array.shift
    * Runtime: O(1)
@@ -53,28 +112,6 @@ class LinkedList {
     this.last = null;
   }
 
-  /**
-   * Adds element to the begining of the list. Similar to Array.unshift
-   * Runtime: O(1)
-   * @param {any} value
-   */
-  addFirst(value) {
-    const node = new Node(value);
-
-    node.next = this.first;
-
-    if (this.first) {
-      this.first.previous = node;
-    } else {
-      this.last = node;
-    }
-
-    this.first = node; // update head
-    this.size++;
-
-    return node;
-  }
-
   /**
    * Removes element to the end of the list
    * similar to Array.pop
@@ -103,17 +140,38 @@ class LinkedList {
   }
 
   /**
-   * Find first occurence of the element matching the value
-   * return index or undefined
+   * Search by value. It finds first occurrence  of
+   * the element matching the value.
    * Runtime: O(n)
    * @param {any} value
+   * @returns {number} return index or undefined
    */
-  contains(value) {
-    for (let current = this.first, index = 0; current; index++, current = current.next) {
+  indexOf(value) {
+    for (let current = this.first, index = 0;
+      current;
+      index += 1, current = current.next) {
       if (current.value === value) {
         return index;
       }
     }
+    return undefined; // not found
+  }
+
+  /**
+   * Search by index
+   * Runtime: O(n)
+   * @param {Number} index position of the element
+   * @returns {Node} element at the specified position in this list.
+   */
+  get(index = 0) {
+    for (let current = this.first, position = 0;
+      current;
+      position += 1, current = current.next) {
+      if (position === index) {
+        return current;
+      }
+    }
+    return undefined; // not found
   }
 
   /**
@@ -138,34 +196,6 @@ 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

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

@@ -96,14 +96,25 @@ describe('LinkedList', () => {
       linkedList.addLast('found');
     });
 
-    describe('#contains', () => {
-      it('should find elements', () => {
-        expect(linkedList.contains(0)).toBe(0);
-        expect(linkedList.contains('found')).toBe(1);
+    describe('#indexOf', () => {
+      it('should find element index', () => {
+        expect(linkedList.indexOf(0)).toBe(0);
+        expect(linkedList.indexOf('found')).toBe(1);
       });
 
       it('should return undefined', () => {
-        expect(linkedList.contains('hola')).toBe(undefined);
+        expect(linkedList.indexOf('hola')).toBe(undefined);
+      });
+    });
+
+    describe('#get', () => {
+      it('should get the element at index 1', () => {
+        expect(linkedList.get(1).value).toBe('found');
+        expect(linkedList.get(0).value).toBe(0);
+      });
+
+      it('should return undefined when index is out of bound', () => {
+        expect(linkedList.get(1000)).toBe(undefined);
       });
     });
 

src/runtimes/wrapper.js

@@ -5,6 +5,11 @@
 // time ./wrapper.js ./is-empty.js < array1M.txt
 // ./wrapper.js ./02-binary-search.js 775 < sortedArray1e1.txt
 
+//
+// Articles
+//
+// https://mathiasbynens.be/notes/javascript-benchmarking
+
 const totalUsage = process.cpuUsage();
 
 // utils