Create PracticalStacks.js

Author: HansUXdev

03-DataStructures/PracticalStacks.js

@@ -0,0 +1,153 @@
+/*
+1. Function call stack:
+In Node.js, a call stack is used to track the order of function calls. 
+Whenever a function is called, it is pushed onto the stack. 
+Once the function is done executing, it is popped off the stack. 
+This ensures that the program knows which function to return to after the current function has finished.
+*/
+function firstFunction() {
+    console.log('First function called');
+    secondFunction();
+  }
+  
+  function secondFunction() {
+    console.log('Second function called');
+    thirdFunction();
+  }
+  
+  function thirdFunction() {
+    console.log('Third function called');
+  }
+  
+firstFunction();
+
+/*
+2. Expression evaluation:
+Stacks can be used to evaluate arithmetic expressions in postfix notation (also known as Reverse Polish Notation). 
+This can be useful when creating a calculator program or when evaluating expressions in a custom language interpreter.
+*/
+function evaluatePostfixExpression(expression) {
+    const stack = [];
+    const operators = {
+      '+': (a, b) => a + b,
+      '-': (a, b) => a - b,
+      '*': (a, b) => a * b,
+      '/': (a, b) => a / b,
+    };
+  
+    expression.split(' ').forEach((token) => {
+      if (token in operators) {
+        const b = stack.pop();
+        const a = stack.pop();
+        stack.push(operators[token](a, b));
+      } else {
+        stack.push(parseFloat(token));
+      }
+    });
+  
+    return stack.pop();
+  }
+  
+  console.log(evaluatePostfixExpression('3 4 + 5 *')); // (3 + 4) * 5 = 35
+  
+/*
+3. Reversing a string:
+Stacks can be used to reverse a string by pushing each character onto a stack and then popping them off in reverse order.
+*/
+function reverseString(str) {
+    const stack = [];
+    for (const char of str) {
+      stack.push(char);
+    }
+  
+    let reversed = '';
+    while (stack.length > 0) {
+      reversed += stack.pop();
+    }
+  
+    return reversed;
+  }
+  
+console.log(reverseString('hello')); // 'olleh'
+  
+/*
+4. Balancing parentheses:
+Stacks can be used to check if a string with parentheses, brackets, and braces is balanced. 
+This can be useful when validating code or user input.
+*/
+function isBalanced(input) {
+    const stack = [];
+    const pairs = {
+      '(': ')',
+      '[': ']',
+      '{': '}',
+    };
+  
+    for (const char of input) {
+      if (char in pairs) {
+        stack.push(char);
+      } else if (Object.values(pairs).includes(char)) {
+        if (stack.length === 0 || pairs[stack.pop()] !== char) {
+          return false;
+        }
+      }
+    }
+  
+    return stack.length === 0;
+  }
+  
+  console.log(isBalanced('{[()]}')); // true
+  console.log(isBalanced('{[(])}')); // false
+  
+/*
+Undo/Redo functionality:
+Stacks can be used to implement undo and redo functionality in an application by keeping track of user actions on two separate stacks.
+*/
+class History {
+    constructor() {
+      this.undoStack = [];
+      this.redoStack = [];
+    }
+  
+    // Add a new action to the undo stack and clear the redo stack
+    addAction(action) {
+      this.undoStack.push(action);
+      this.redoStack = [];
+    }
+  
+    // Undo the last action by moving it from the undo stack to the redo stack
+    undo() {
+      if (this.undoStack.length === 0) return;
+  
+      const action = this.undoStack.pop();
+      this.redoStack.push(action);
+      console.log(`Undo: ${action}`);
+    }
+  
+    // Redo the last undone action by moving it back from the redo stack to the undo stack
+    redo() {
+      if (this.redoStack.length === 0) return;
+  
+      const action = this.redoStack.pop();
+      this.undoStack.push(action);
+      console.log(`Redo: ${action}`);
+    }
+  }
+  
+  // Example usage
+  const history = new History();
+  
+  history.addAction('Type A');
+  history.addAction('Type B');
+  history.addAction('Type C');
+  
+  history.undo(); // Undo: Type C
+  history.undo(); // Undo: Type B
+  
+  history.redo(); // Redo: Type B
+  history.addAction('Type D'); // Performing a new action resets the redo history
+  
+  history.redo(); // No action, as redo history has been reset
+  
+
+