🌊 - Richelle

lib/problems.js

@@ -1,17 +1,71 @@
+const Stack = require('./stack')
+
 /*
-Time Complexity: ?
-Space Complexity: ?
+Time Complexity: O(n) worst case if all are opening brackets
+Space Complexity: same as above
 */
 const balanced = (str) => {
-    throw new Error("This method has not been implemented!");
+    const openers = {
+        '{': '}',
+        '[': ']',
+        '(': ')'
+    }
+
+    let stack = new Stack;
+    for (const char of str) {
+        if (openers[char]) { // the char is an opening bracket
+            stack.push(char);
+        } else { // the char is a closing bracker
+            // pop off of the stack to see if it's the correct opener
+            if (openers[stack.pop()] !== char) return false;
+        }
+    }
+
+    return stack.isEmpty();
 }
 
 /*
-Time Complexity: ?
-Space Complexity: ?
+Time Complexity: O(n)
+Space Complexity: O(n)
 */
 const evaluatePostfix = (expr) => {
-    throw new Error("This method has not been implemented!");
+    // assumes only the operators listed below would be given
+    // also any non-operator would be an integer
+    const operators = {'+': add, '-': subtract, '/': divide, '*': multiply};
+    let stack = new Stack;
+
+    for (const char of expr) {
+        if (operators[char]) {
+            const secondNum = stack.pop();
+            const firstNum = stack.pop();
+
+            stack.push(operators[char](parseInt(firstNum), parseInt(secondNum)))
+        } else {
+            stack.push(char);
+        }
+    }
+
+    return parseInt(stack.pop());
+}
+
+const add = (num1, num2) => {
+    return (num1 + num2);
+}
+
+const subtract = (num1, num2) => {
+    return (num1 - num2);
+}
+
+const multiply = (num1, num2) => {
+    return (num1 * num2)
+}
+
+const divide = (num1, num2) => {
+    if (num2 === 0) {
+        throw new Error('Cannot divide by 0');
+    } else {
+        return (num1 / num2);
+    }
 }
 
 exports.balanced = balanced;

lib/queue.js

@@ -1,27 +1,62 @@
 class Queue {
-    constructor() {
-        // this.store = ...
-        throw new Error("This method has not been implemented!");
+    constructor(size = 20) {
+        this.store = new Array(size);
+        this.maxSize = size;
+        this.head = -1;
+        this.tail = -1;
     }
 
-    enqueue(element) {
-        throw new Error("This method has not been implemented!");
+    enqueue(value) {
+        if (((this.tail + 1) % this.maxSize === this.head) || (this.head == 0 && this.tail == this.store.length -1)) {
+            throw new Error('Queue is full.');
+        } else if (this.head === -1) {
+            this.head = 0;
+            this.tail = 1;
+            this.store[this.head] = value;
+        } else {
+            this.store[this.tail] = value;
+            this.tail = (this.tail + 1) % this.maxSize;
+        }
+
     }
 
     dequeue() {
-        throw new Error("This method has not been implemented!");
+        if (this.head === -1) throw new Error("The queue is empty.");
+
+        const data = this.store[this.head];
+        this.store[this.head] = null;
+
+        // increment the head (consider wrapping around)
+        this.head = (this.head + 1) % this.maxSize;
+
+        // if head === tail then the list is empty
+        // reset head and tail to -1
+        if (this.head === this.tail) this.head = this.tail = -1;
+
+        return data;
     }
 
     front() {
-        throw new Error("This method has not been implemented!");
+        return this.store[this.head];
     }
 
     size() {
-        throw new Error("This method has not been implemented!");
+        let count = 0;
+        let visited = 0;
+
+        while (visited < this.maxSize) {
+            if (!!this.store[visited]) {
+                count ++;
+            }
+            visited ++;
+        }
+
+        return count;
     }
 
     isEmpty() {
-        throw new Error("This method has not been implemented!");
+        return this.tail === this.head;
+        // return !this.store[this.head];
     }
 
     toString() {

lib/stack.js

@@ -1,19 +1,22 @@
+const LinkedList = require('./linked-list')
+
 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(item) {
+        this.store.addFirst(item);
     }
 
     pop() {
-        throw new Error("This method has not been implemented!");
+        const first = this.store.getFirst();
+        this.store.delete(first);
+        return first;
     }
 
     isEmpty() {
-        throw new Error("This method has not been implemented!");
+        return this.store.isEmpty();
     }
 
     toString() {