Js stack

.gitignore

@@ -99,3 +99,4 @@ ENV/
 
 # mypy
 .mypy_cache/
+node_modules/

README.md

@@ -8,12 +8,20 @@
 
 **Testing Tools**: pytest, pytest-cov
 
+## Sorting Algorithms: 
+
+* **Insertion Sort** - *The insertion sort algorithm sorts a list of numbers by looping through each individual number in the list one by one, and (if they are smaller than the last index) swapping the two numbers. Unlike bubble sort, after this swap the sort continues to swap the number down into lower indexed positions until it finds the right position. The runtime for this function is at worst-case O(n^2), because in that scenario the list would be exactly the reverse of what it should be.*
+
 ## Data Structures:
 
 * **Binary Search Tree** — *a BST is a "tree shaped" data structure containing nodes. Each node can have a maximum of two children or "leaves," and all node values are properly located based on its parents and siblings values. Nodes to the left of the "root"/head node have values smaller than the root. Those to the right have values larger than the root. There are no duplicate values.* 
 
 * **Trie Tree** - *a Trie Tree is a "tree shaped" data structure containing nodes with references to letters. These nodes string together (using each node's "children" and "parent" attriutes) to form words. This tree allows for quick lookup time of words, and is used for things such as word suggestion/auto-complete.*
 
+* **Linked List (JavaScript)** - *A singly linked list is a data structure made of nodes, all of which have a single "next" pointer pointing from the head to the tail. The runtime of traversing the LL is O(n) because it grows proportionally with the length of the list.*
+
+* **Stack (JavaScript)** - *A stack is much like a singly linked list. It can be visualized as a stack of cards, and it is a "last in, first out" data structure that pops and pushes to the same end (or 'top') of the structure. It has O(n) runtime.*
+
 ## Time Complexities:
 
 * balance() = *This BST function returns the balance (or size difference) between the left and right parts of the tree. Its runtime is O(1), because it always takes the same amount of time to run regardless of tree size, and only performs simple subtraction.*

js-src/js-doubly-linked-list.js

@@ -0,0 +1,138 @@
+"use strict";
+
+class Node {
+    constructor(data, nextNode=null, prevNode=null) {
+        this.data = data
+        this.nextNode = nextNode
+        this.prevNode = prevNode
+    }
+}
+
+class DLL {
+    constructor(iter=null) {
+        this.head = null
+        this.tail = null
+        this.counter = 0
+        if (Array.isArray(iter)) {
+            iter.forEach(item => this.push(item))
+        }
+        else if (iter !== null) {
+            throw 'LinkedList only takes arrays as inputs.'
+        }
+    }
+
+    push(val) {
+        this.head = new Node(val, this.head)
+        this.counter ++
+        if (this.size() === 1) {
+            this.tail = this.head
+        } else {
+            this.head.nextNode.prevNode = this.head
+        }
+    }
+
+    pop() {
+        if (this.size() === 0) {
+            throw 'Cannot pop() from empty DoublyLinkedList.'
+        }
+        this.counter --
+        var output = this.head.data
+        this.head = this.head.nextNode
+        if (this.head) {
+            this.head.prevNode = null
+        }
+        return output
+    }
+
+    size() {
+        return this.counter
+    }
+
+    search(val) {
+        var curr = this.head
+        while (curr.data !== val) {
+            if (curr.nextNode === null) {
+                throw 'This value is not in the LinkedList.'
+            }
+            curr = curr.nextNode
+        }
+        return curr
+    }
+
+    remove(val) {
+        var curr = this.head
+        var prev = null
+        while (curr) {
+            if (curr.data == val) {
+                this.counter --
+                if (curr == this.head) {
+                    if (this.head == this.tail) {
+                        this.head = null
+                        this.tail = null
+                        return curr.data
+                    }
+                    this.head = curr.nextNode
+                    this.head.prevNode = null
+                    return curr.data
+                }
+                prev.nextNode = curr.nextNode
+                curr.nextNode.prevNode = prev
+                return curr.data
+            }
+            if (curr.nextNode == null) {
+                throw 'Values not in the DoublyLinkedList cannot be removed.'
+            }
+            prev = curr
+            curr = curr.nextNode
+        }
+        return curr
+    }
+
+    append(val){
+        var firstTail = this.tail
+        this.tail = new Node(val, this.prevNode=this.tail)
+        this.counter ++
+        if(firstTail){
+            firstTail.nextNode = this.tail
+        } else {
+            this.head = this.tail
+        }
+        this.tail.nextNode = null
+    }
+
+    shift(){
+        if (!this.tail){
+            throw "Cannot shift() from empty DLL."
+        }
+        var output = this.tail.data
+        this.tail = this.tail.prevNode
+        if(this.tail) {
+            this.tail.nextNode = null
+        } else {
+            this.head = null
+        }
+        this.counter --
+        return output
+    }
+
+
+    display() {
+        var start_paren = "("
+        if (this.head === null) {
+            return '()'
+        }
+        var curr = this.head
+        while (curr) {
+            if (curr.nextNode === null) {
+                start_paren += curr.data + ')'
+                return start_paren
+            }
+            else {
+                start_paren += curr.data + ', '
+                curr = curr.nextNode
+            }
+        }
+    }
+}
+
+module.exports = DLL

js-src/js-linked-list.js

@@ -0,0 +1,95 @@
+'use strict';
+
+class Node {
+  constructor(data, nextNode=null) {
+    this.data = data;
+    this.nextNode = nextNode;
+  }
+}
+
+class LL {
+  constructor(iter=null) {
+    this.head = null;
+    this.counter = 0;
+    if (Array.isArray(iter)) {
+      iter.forEach(item => this.push(item));
+    }
+    else if (iter !== null) {
+      return 'LinkedList only takes arrays as inputs.';
+    }
+  }
+
+  push(val) {
+    this.head = new Node(val, this.head);
+    this.counter ++;
+  }
+
+  pop() {
+    if (this.counter === 0) {
+      return 'Cannot pop() from empty LinkedList.';
+    }
+    var output = this.head.data;
+    this.head = this.head.nextNode;
+    this.counter --;
+    return output;
+  }
+
+  size() {
+    return this.counter;
+  }
+
+  search(val) {
+    var curr = this.head;
+    while (curr.data !== val) {
+      if (curr.nextNode === null) {
+        return 'This value is not in the LinkedList.';
+      }
+      curr = curr.nextNode;
+    }
+    return curr;
+  }
+
+  remove(val) {
+    var curr = this.head;
+    if (this.head.data === val) {
+      this.head = this.head.nextNode;
+      this.counter --;
+      return val;
+    }
+    if (this.head === null) {
+      return 'Cannot remove vals from empty LinkedList.';
+    }
+    while (curr) {
+      if (curr.nextNode === null) {
+        return 'Values not in the LinkedList cannot be removed.';
+      }
+      else if (curr.nextNode.data === val) {
+        curr.nextNode = curr.nextNode.nextNode;
+        this.counter --;
+        return val;
+      }
+      curr = curr.nextNode;
+    }
+  }
+
+  display() {
+    var start_paren = '(';
+    if (this.head === null) {
+      return '()';
+    }
+    var curr = this.head;
+    while (curr) {
+      if (curr.nextNode === null) {
+        start_paren += curr.data + ')';
+        return start_paren;
+      }
+      else {
+        start_paren += curr.data + ', ';
+        curr = curr.nextNode;
+      }
+    }
+  }
+}
+
+module.exports = LL;
+

js-src/js-stack.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const LL = require("./js-linked-list")
+// import {LL} from "js-linked-list.js"
+
+class Stack {
+    constructor(iter=null){
+        this.linked = new LL()
+        if(Array.isArray(iter)){
+            iter.forEach(item => this.push(item))
+        }
+    }
+
+    size(){
+        return this.linked.size()
+    }
+
+    push(val){
+        this.linked.push(val)
+    }
+
+    pop(){
+        return this.linked.pop()
+    }
+
+}
+
+module.exports = Stack

js-src/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "js-data-structures",
+  "version": "1.0.0",
+  "description": "",
+  "main": "js-linked-list.js",
+  "dependencies": {
+    "chai": "^4.1.2"
+  },
+  "devDependencies": {
+    "mocha": "^4.0.1"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "author": "Ya bish",
+  "license": "ISC"
+}