Merge pull request #1 from shadowcodex/stacks

Stacks

Author: shadowcodex

.gitignore

@@ -0,0 +1 @@
+node_modules

LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010-2018 Google, Inc. http://angularjs.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

benchmark/queues.js

@@ -0,0 +1,33 @@
+let { queues } = require('./../index');
+let ptime = require('quick-ptime');
+
+
+// setup stacks
+let queue = new queues.Queue();
+let arrayQueue = new queues.ArrayQueue();
+
+// enqueue 100,000 items into the queue
+ptime.setTime('queue100000');
+for(let i = 0; i < 100000; i++) {
+    queue.enqueue('value');
+}
+console.log("Enqueue 100,000 Queue timing:", ptime.elapsedTime('queue100000').formatted);
+
+ptime.setTime('arrayqueue100000');
+for(let i = 0; i < 100000; i++) {
+    arrayQueue.enqueue('value');
+}
+console.log("Enqueue 100,000 Array Queue timing:", ptime.elapsedTime('arrayqueue100000').formatted);
+
+// dequeue 100,000 items into the queue
+ptime.setTime('dqueue100000');
+for(let i = 0; i < 100000; i++) {
+    queue.dequeue();
+}
+console.log("Dequeue 100,000 Queue timing:", ptime.elapsedTime('dqueue100000').formatted);
+
+ptime.setTime('darrayqueue100000');
+for(let i = 0; i < 100000; i++) {
+    arrayQueue.dequeue();
+}
+console.log("Dequeue 100,000 Array Queue timing:", ptime.elapsedTime('darrayqueue100000').formatted);

benchmark/stacks.js

@@ -0,0 +1,34 @@
+let { stacks } = require('./../index');
+let ptime = require('quick-ptime');
+
+
+// setup stacks
+let stack = new stacks.Stack();
+let arrayStack = new stacks.ArrayStack();
+
+// push 100,000 items onto the stack
+ptime.setTime('stack100000');
+for(let i = 0; i < 100000; i++) {
+    stack.push('value');
+}
+console.log("Push 100,000 Stack timing:", ptime.elapsedTime('stack100000').formatted);
+
+ptime.setTime('arraystack100000');
+for(let i = 0; i < 100000; i++) {
+    arrayStack.push('value');
+}
+console.log("Push 100,000 Array Stack timing:", ptime.elapsedTime('arraystack100000').formatted);
+
+
+// pop 100,000 items off the stack
+ptime.setTime('pstack100000');
+for(let i = 0; i < 100000; i++) {
+    stack.pop()
+}
+console.log("Pop 100,000 Stack timing:", ptime.elapsedTime('pstack100000').formatted);
+
+ptime.setTime('parraystack100000');
+for(let i = 0; i < 100000; i++) {
+    stack.pop()
+}
+console.log("Pop Array 100,000 Stack timing:", ptime.elapsedTime('parraystack100000').formatted);

index.js

@@ -0,0 +1,7 @@
+const stacks = require('./lib/stacks');
+const queues = require('./lib/queues');
+
+module.exports = {
+    stacks,
+    queues
+}

lib/linkedLists.js

@@ -0,0 +1,28 @@
+class LinkedList {
+    constructor () {
+        this.current = {};
+    }
+
+    add(value) {
+        
+    }
+
+    remove() {
+       
+    }
+
+    peek() {
+        return this.current;
+    }
+}
+
+class DoublyLinkedList {
+    constructor () {
+
+    }
+}
+
+module.exports = {
+    LinkedList,
+    DoublyLinkedList
+}

lib/queues.js

@@ -0,0 +1,82 @@
+class Queue {
+    constructor () {
+        this.first = {};
+        this.last = {};
+        this.length = 0;
+    }
+
+    enqueue(data) {
+        let node = {value: data};
+        if(this.length > 0) {
+            this.last.prev = node;
+            this.last = node;
+            this.length++;
+            return this.length;            
+        } else {
+            this.first = node;
+            this.last = node;
+            this.length++;
+            return this.length;
+        }
+    }
+
+    dequeue() {
+        if(this.length === 1) {
+            const value = this.first.value;
+            this.first = {};
+            this.last = {};
+            this.length--;
+            return value;
+        } if(this.length > 1) {
+            const value = this.first.value;
+            this.first = this.first.prev;
+            this.length--;
+            return value;
+        } else {
+            return undefined;
+        }
+    }
+
+    peek() {
+        return this.first.value;
+    }
+
+    length() {
+        return this.length;
+    }
+
+    isEmpty() {
+        return this.length === 0;
+    }
+}
+
+class ArrayQueue {
+    constructor () {
+        this.queue = [];
+    }
+
+    enqueue(data) {
+        return this.queue.unshift(data);
+    }
+
+    dequeue() {
+        return this.queue.pop();
+    }
+
+    peek() {
+        return this.queue[this.queue.length - 1];
+    }
+
+    length() {
+        return this.queue.length;
+    }
+
+    isEmpty() {
+        return this.queue.length === 0;
+    }
+}
+
+module.exports = {
+    Queue,
+    ArrayQueue
+}

lib/stacks.js

@@ -0,0 +1,71 @@
+class Stack {
+    constructor () {
+        this.top = {};        
+        this.length = 0;
+    }
+
+    push(data) {
+        let node = {
+            value: data,
+            prev: this.top
+        };
+        this.top = node;
+        this.length++;
+        return this.length;        
+    }
+
+    pop() {
+        if(this.length === 0) {
+            return undefined;
+        }
+
+        let value = this.top.value;
+        this.top = this.top.prev;
+        this.length--;
+        return value;        
+    }
+
+    peek() {
+        return this.top.value;
+    }
+
+    height() {
+        return this.length;
+    }
+
+    isEmpty() {
+        return this.length === 0;
+    }
+}
+
+class ArrayStack {
+    constructor() {
+        this.stack = [];
+    }
+
+    push(data) {
+        return this.stack.push(data);        
+    }
+
+    pop() {
+        return this.stack.pop();
+    }
+
+    peek() {
+        return this.stack[this.stack.length - 1];
+    }
+
+    height() {
+        return this.stack.length;
+    }
+
+    isEmpty() {
+        return this.stack.length === 0;
+    }
+}
+
+
+module.exports = {
+    Stack,
+    ArrayStack
+}

package.json

@@ -0,0 +1,21 @@
+{
+  "name": "data-theory",
+  "version": "0.0.1",
+  "description": "A collection of data theory and structures in JavaScript.",
+  "main": "index.js",
+  "repository": "https://github.com/shadowcodex/data-theory.git",
+  "author": "shadowcodex <[email protected]>",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "test": "npx mocha",
+    "bench:stacks": "node benchmark/stacks.js",
+    "bench:queues": "node benchmark/queues.js"
+  },
+  "devDependencies": {
+    "mocha": "^5.2.0"
+  },
+  "dependencies": {
+    "quick-ptime": "^1.0.0"
+  }
+}

test/stacks.js

@@ -0,0 +1,76 @@
+var assert = require('assert');
+const { stacks } = require('../index');
+
+describe('Stack', function() {
+  it('should make a new stack', function() {
+    const stack = new stacks.Stack();
+    assert.equal(stack.height(), 0);    
+  });
+
+  it('should push an item on to the stack', function() {
+    let stack = new stacks.Stack();
+    stack.push('item');
+
+    assert.equal(stack.peek(), 'item');
+  });
+
+  it('should pop an item off the stack', function() {
+    let stack = new stacks.Stack();
+    stack.push('item');
+    let value = stack.pop();
+    assert.equal(value, 'item');
+  });
+
+  it('should push three items on and pop them off in order', function() {
+    let stack = new stacks.Stack();
+    stack.push('item1');
+    stack.push('item2');
+    stack.push('item3');
+
+    let value = stack.pop();
+    assert.equal(value, 'item3');
+    
+    value = stack.pop();
+    assert.equal(value, 'item2');
+    
+    value = stack.pop();
+    assert.equal(value, 'item1');
+  });
+});
+
+describe('Array Stack', function() {
+  it('should make a new stack', function() {
+    const stack = new stacks.ArrayStack();
+    assert.equal(stack.height(), 0);    
+  });
+
+  it('should push an item on to the stack', function() {
+    let stack = new stacks.ArrayStack();
+    stack.push('item');
+
+    assert.equal(stack.peek(), 'item');
+  });
+
+  it('should pop an item off the stack', function() {
+    let stack = new stacks.ArrayStack();
+    stack.push('item');
+    let value = stack.pop();
+    assert.equal(value, 'item');
+  });
+
+  it('should push three items on and pop them off in order', function() {
+    let stack = new stacks.ArrayStack();
+    stack.push('item1');
+    stack.push('item2');
+    stack.push('item3');
+
+    let value = stack.pop();
+    assert.equal(value, 'item3');
+    
+    value = stack.pop();
+    assert.equal(value, 'item2');
+    
+    value = stack.pop();
+    assert.equal(value, 'item1');
+  });
+});