Cedar-Bailey

lib/problems.js

@@ -0,0 +1,80 @@
+const Stack = require("../lib/stack");
+
+/*
+Time Complexity: O(n) single loop
+Space Complexity: O(n) single stack used
+*/
+const balanced = (string) => {
+    // if string is empty return true
+    if (string.length === 0) return true;
+
+    //initialize stack
+    let stack = new Stack;
+    // create hasp map for brackets/parentheses
+    let hash = {
+      '(' : ')',
+      '[' : ']',
+      '{' : '}'
+    };
+
+    // scan each element of the string
+    for (let i = 0; i < string.length; i++) {
+      // if the element is an opener, push to the stack
+      if (string[i] === '(' || string[i] === '{' || string[i] === '[') {
+        stack.push(string[i]);    
+      } else if (hash[stack.pop()] !== string[i]) {
+        // else pop the stack, if that element is not the corresponding opener return false
+        // otherwise continue the loop
+        return false;
+      }
+    };
+
+    // if the stack is empty, return true
+    return stack.isEmpty() ? true : false;
+
+}
+
+/*
+Time Complexity: O(n) single loop
+Space Complexity: O(n) single stack
+*/
+const evaluatePostfix = (expr) => {
+    let stack = new Stack;
+
+    // scan each character in the expression
+    for(let i=0;i<expr.length;i++) {
+      let ch = expr[i];
+
+      if (ch >= '0' && ch <= '9') {
+        //convert string to integer
+        stack.push(parseInt(ch, 10));
+      } else {
+        let val1 = stack.pop();
+        let val2 = stack.pop();
+
+        // switch case that runs through the possible operators
+        switch (ch)
+          {
+              case '+':
+              stack.push(val2 + val1);
+              break;
+
+              case '-':
+              stack.push(val2 - val1);
+              break;
+
+              case '/':
+              stack.push(parseInt(val2 / val1, 10));
+              break;
+
+              case '*':
+              stack.push(val2 * val1);
+              break;
+          }
+      }
+    }
+    return stack.pop();
+}
+
+exports.balanced = balanced;
+exports.evaluatePostfix = evaluatePostfix;

lib/queue.js

@@ -1,33 +1,52 @@
 class Queue {
     constructor() {
-        // this.store = ...
-        throw new Error("This method has not been implemented!");
+        this.store = new Array(this.capacity);
+        this.length = 0;
+        this.capacity = 20;
+        this.head = 0;
+        this.tail = -1;
     }
 
     enqueue(element) {
-        throw new Error("This method has not been implemented!");
+        if (this.length >= this.capacity) return;
+
+        this.tail = (this.tail + 1) % this.capacity;
+        this.store[this.tail % this.capacity] = element;
+        this.length++;
     }
 
     dequeue() {
-        throw new Error("This method has not been implemented!");
+        if (this.isEmpty()) return;
+
+        let result = this.store[this.head % this.capacity];
+
+        this.store[this.head % this.capacity] = null;
+
+        this.head = (this.head + 1) % this.capacity;
+        this.length--;
+        return result;
     }
 
     front() {
-        throw new Error("This method has not been implemented!");
+        return this.head;
     }
 
     size() {
-        throw new Error("This method has not been implemented!");
+        return this.length;
     }
 
     isEmpty() {
-        throw new Error("This method has not been implemented!");
+        return this.length === 0;
+    }
+
+    isFull() {
+        return this.length === this.capacity;
     }
 
     toString() {
         let arr;
         if (this.head > this.tail) {
-            arr = this.store.slice(this.head, this.capacity).concat(this.store.slice(0, this.tail));
+            arr = this.store.slice(this.head, this.capacity).concat(this.store.slice(0, this.tail + 1));
         } else {
             arr = this.store
         }

lib/stack.js

@@ -1,23 +1,26 @@
+const LinkedList = require("./linked-list.js");
+
 class Stack {
     constructor() {
-        // this.store = ...
-        throw new Error("This method has not been implemented!");
+        this.store = new LinkedList();
     }
 
-    push() {
-        throw new Error("This method has not been implemented!");
+    push(value) {
+        this.store.addLast(value);
     }
 
     pop() {
-        throw new Error("This method has not been implemented!");
+        let last = this.store.getLast();
+        this.store.delete(last);
+        return last;
     }
 
     isEmpty() {
-        throw new Error("This method has not been implemented!");
+        return this.store.isEmpty();
     }
 
     toString() {
-        JSON.stringify(this.store);
+        this.store.toString();
     }
 }