fixed array stack to be both bounded and unbounded

Author: shadowcodex

benchmark/stacks.js

@@ -3,32 +3,45 @@ let ptime = require('quick-ptime');
 
 
 // setup stacks
-let stack = new stacks.Stack();
-let arrayStack = new stacks.ArrayStack();
+let linkedStack = new stacks.LinkedStack();
+let uArrayStack = new stacks.UArrayStack();
+let bArrayStack = new stacks.BArrayStack(100000);
 
 // push 100,000 items onto the stack
 ptime.setTime('stack100000');
 for(let i = 0; i < 100000; i++) {
-    stack.push('value');
+    linkedStack.push('value');
 }
-console.log("Push 100,000 Stack timing:", ptime.elapsedTime('stack100000').formatted);
+console.log("Push 100,000 Linked Stack timing:", ptime.elapsedTime('stack100000').formatted);
 
-ptime.setTime('arraystack100000');
+ptime.setTime('uarraystack100000');
 for(let i = 0; i < 100000; i++) {
-    arrayStack.push('value');
+    uArrayStack.push('value');
 }
-console.log("Push 100,000 Array Stack timing:", ptime.elapsedTime('arraystack100000').formatted);
+console.log("Push 100,000 Unbounded Array Stack timing:", ptime.elapsedTime('uarraystack100000').formatted);
+
+ptime.setTime('barraystack100000');
+for(let i = 0; i < 100000; i++) {
+    bArrayStack.push('value');
+}
+console.log("Push 100,000 Bounded Array Stack timing:", ptime.elapsedTime('barraystack100000').formatted);
 
 
 // pop 100,000 items off the stack
 ptime.setTime('pstack100000');
 for(let i = 0; i < 100000; i++) {
-    stack.pop()
+    linkedStack.pop()
 }
 console.log("Pop 100,000 Stack timing:", ptime.elapsedTime('pstack100000').formatted);
 
-ptime.setTime('parraystack100000');
+ptime.setTime('puarraystack100000');
+for(let i = 0; i < 100000; i++) {
+    uArrayStack.pop()
+}
+console.log("Pop 100,000 Unbounded Array Stack timing:", ptime.elapsedTime('puarraystack100000').formatted);
+
+ptime.setTime('pbarraystack100000');
 for(let i = 0; i < 100000; i++) {
-    stack.pop()
+    bArrayStack.pop()
 }
-console.log("Pop 100,000 Array Stack timing:", ptime.elapsedTime('parraystack100000').formatted);
+console.log("Pop 100,000 Bounded Array Stack timing:", ptime.elapsedTime('pbarraystack100000').formatted);

lib/stacks.js

@@ -1,15 +1,15 @@
-class Stack {
+class LinkedStack {
     constructor () {
-        this.top = {};        
+        this.topNode = {};        
         this.length = 0;
     }
 
     push(data) {
         let node = {
             value: data,
-            prev: this.top
+            prev: this.topNode
         };
-        this.top = node;
+        this.topNode = node;
         this.length++;
         return this.length;        
     }
@@ -19,14 +19,12 @@ class Stack {
             return undefined;
         }
 
-        let value = this.top.value;
-        this.top = this.top.prev;
-        this.length--;
-        return value;        
+        this.topNode = this.topNode.prev;
+        this.length--;        
     }
 
-    peek() {
-        return this.top.value;
+    top() {
+        return this.topNode.value;
     }
 
     height() {
@@ -38,7 +36,7 @@ class Stack {
     }
 }
 
-class ArrayStack {
+class UArrayStack {
     constructor() {
         this.stack = [];
     }
@@ -48,10 +46,10 @@ class ArrayStack {
     }
 
     pop() {
-        return this.stack.pop();
+        this.stack.pop();
     }
 
-    peek() {
+    top() {
         return this.stack[this.stack.length - 1];
     }
 
@@ -64,8 +62,60 @@ class ArrayStack {
     }
 }
 
+class BArrayStack {
+    constructor(size) {
+        const DEFAULT_SIZE = 100;
+        let use = !!size ? size : DEFAULT_SIZE;
+        this.stack = [];
+        for(let i = 0; i < use; i++) {
+            this.stack[i] = null;
+        }                             
+        this.topIndex = -1;
+    }
+
+    height() {
+        return this.topIndex + 1;
+    }
+
+    isEmpty() {
+        return this.topIndex === -1 ? true : false;        
+    }
+
+    isFull() {
+        return this.topIndex === this.stack.length - 1 ? true : false;
+    }
+
+    push(item) {
+        if(!this.isFull()) {
+            this.topIndex++;
+            this.stack[this.topIndex] = item;
+        } else {
+            throw new Error('Stack too deep');
+        }
+    }
+
+    pop() {
+        if(!this.isEmpty()) {
+            this.stack[this.topIndex] = null;
+            this.topIndex--;
+        } else {
+            throw new Error('Stack already empty');
+        }
+    }
+
+    top() {
+        if(!this.isEmpty()) {
+            return this.stack[this.topIndex];
+        } else {
+            return undefined;
+        }
+    }
+
+}
+
 
 module.exports = {
-    Stack,
-    ArrayStack
+    LinkedStack,
+    UArrayStack,
+    BArrayStack
 }

test/stacks.js

@@ -1,76 +1,111 @@
 var assert = require('assert');
 const { stacks } = require('../index');
 
-describe('Stack', function() {
+describe('LinkedStack', function() {
   it('should make a new stack', function() {
-    const stack = new stacks.Stack();
+    const stack = new stacks.LinkedStack();
     assert.equal(stack.height(), 0);    
   });
 
   it('should push an item on to the stack', function() {
-    let stack = new stacks.Stack();
+    let stack = new stacks.LinkedStack();
+    stack.push('item');    
+    
+    assert.equal(stack.top(), 'item');
+  });
+
+  it('should pop an item off the stack', function() {
+    let stack = new stacks.LinkedStack();
+    stack.push('item');
+    stack.pop();
+
+    assert.equal(stack.top(), undefined);
+  });
+
+  it('should push three items on and pop tone off leaving 2 items', function() {
+    let stack = new stacks.LinkedStack();
+    stack.push('item1');
+    stack.push('item2');
+    stack.push('item3');
+
+    stack.pop();
+    assert.equal(stack.height(), 2);
+    assert.equal(stack.top(), 'item2');   
+  });
+});
+
+
+
+
+
+
+describe('Unbounded Array Stack', function() {
+  it('should make a new stack', function() {
+    const stack = new stacks.UArrayStack();
+    assert.equal(stack.height(), 0);    
+  });
+
+  it('should push an item on to the stack', function() {
+    let stack = new stacks.UArrayStack();
     stack.push('item');
 
-    assert.equal(stack.peek(), 'item');
+    assert.equal(stack.top(), 'item');
   });
 
   it('should pop an item off the stack', function() {
-    let stack = new stacks.Stack();
+    let stack = new stacks.UArrayStack();
     stack.push('item');
-    let value = stack.pop();
-    assert.equal(value, 'item');
+    stack.pop();
+    
+    assert.equal(stack.top(), undefined);
   });
 
-  it('should push three items on and pop them off in order', function() {
-    let stack = new stacks.Stack();
+  it('should push three items on and pop tone off leaving 2 items', function() {
+    let stack = new stacks.UArrayStack();
     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');
+    stack.pop();
+    assert.equal(stack.height(), 2);
+    assert.equal(stack.top(), 'item2');   
   });
 });
 
-describe('Array Stack', function() {
+
+
+
+
+
+describe('Bounded Array Stack', function() {
   it('should make a new stack', function() {
-    const stack = new stacks.ArrayStack();
+    const stack = new stacks.BArrayStack();
     assert.equal(stack.height(), 0);    
   });
 
   it('should push an item on to the stack', function() {
-    let stack = new stacks.ArrayStack();
+    let stack = new stacks.BArrayStack();
     stack.push('item');
 
-    assert.equal(stack.peek(), 'item');
+    assert.equal(stack.top(), 'item');
   });
 
   it('should pop an item off the stack', function() {
-    let stack = new stacks.ArrayStack();
+    let stack = new stacks.BArrayStack();
     stack.push('item');
-    let value = stack.pop();
-    assert.equal(value, 'item');
+    stack.pop();
+    
+    assert.equal(stack.top(), undefined);
   });
 
-  it('should push three items on and pop them off in order', function() {
-    let stack = new stacks.ArrayStack();
+  it('should push three items on and pop tone off leaving 2 items', function() {
+    let stack = new stacks.BArrayStack();
     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');
+    stack.pop();
+    assert.equal(stack.height(), 2);
+    assert.equal(stack.top(), 'item2');   
   });
 });