Update stack algorithms

Author: sudheerj

README.md

@@ -116,7 +116,7 @@ List of Programs related to data structures and algorithms
 
 | No. | Name | Source | Playground | Documentation | Level | Pattern |
 | :-: | :----------------- | :------------------------------------------------------------------------------------------------------------------------------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------: | :----: | :------------------------: |
-| 1 | Sort Stack | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js) | Easy | Stack push & pop |
+| 1 | Sort Stack | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/1.sortStack/sortStack.md) | Easy | Stack push & pop |
 | 2 | Balanced Brackets | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.md) | Medium | Stack push and pop |
 | 3 | Reverse Polish Notation | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/3.reversePolishNotation/reversePolishNotation.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/3.reversePolishNotation/reversePolishNotation.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/3.reversePolishNotation/reversePolishNotation.md) | Medium | Stack push & pop |
 | 4 | Daily Temperatures | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/4.dailyTemperatures/dailyTemperatures.md) | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/4.dailyTemperatures/dailyTemperatures.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/stack/4.dailyTemperatures/dailyTemperatures.md) | Medium | Monotonic decreasing stack |

src/javascript/algorithms/stack/1.sortStack/sortStack.js

@@ -1,51 +1,39 @@
 class MyStack {
-
  constructor() {
- this.array = []; // Array is used to implement stack
+ this.items = [];
  }
 
- // List of main functions of stack data structure
-
+ // Core stack operations
  push(value) {
- // push an element into the array
- this.array.push(value);
+ this.items.push(value);
  }
 
  pop() {
- // Return null if stack is empty
  if (this.isEmpty()) {
- return null;
+ throw new Error("Stack Underflow: Cannot pop from an empty stack.");
  }
-
- return this.array.pop(); // return top most element from the stack and removes the same element
+ return this.items.pop();
  }
 
  peek() {
- // Return null if stack is empty
  if (this.isEmpty()) {
- return null;
+ throw new Error("Stack Underflow: Cannot peek from an empty stack.");
  }
- 
- return this.array[this.array.length - 1]; // return top most element from the stack without removing the element
+ return this.items[this.items.length - 1];
  }
 
- // List of helper functions
-
+ // Helper functions
  isEmpty() {
- return this.array.length === 0; // return true if stack is empty
+ return this.items.length === 0;
  }
 
  size() {
- return this.array.length;
+ return this.items.length;
  }
 
  printStack() {
- let data = "";
- for (let i = 0; i < this.array.length; i++)
- data += this.array[i] + " ";
- return data;
+ return this.items.join(' ');
  }
-
 }
 
 function sortStack(stack) {
@@ -57,7 +45,7 @@ function sortStack(stack) {
  let top = tempStack.pop();
  stack.push(top);
  }
- tempStack.push(temp); 
+ tempStack.push(temp);
  }
  stack.array = tempStack.array;
 }

src/javascript/algorithms/stack/1.sortStack/sortStack.md

@@ -1,39 +1,38 @@
-**Description:**
+# Sort Stack
+
+Sorting a stack means arranging its elements in ascending order (smallest on top) using only stack operations and an auxiliary stack. This is a classic problem that demonstrates stack manipulation and algorithmic thinking.
+The stack is sorted using another temporary stack, without using any other data structures like arrays or linked lists.
+
+
+## Problem Statement
+
 Given a stack of integers `nums`, sort it in ascending order using another temporary stack.
 
-## Examples:
-Example 1
-Input: [8, 2, 4, 1, 5, 3] 
+## Examples
+
+**Example 1** 
+Input: [8, 2, 4, 1, 5, 3] 
 Output: [1, 2, 3, 4, 5, 8]
 
-Example 2
-Input: [6, 5, 4, 3, 2, 1] 
+**Example 2** 
+Input: [6, 5, 4, 3, 2, 1]  
 Output: [1, 2, 3, 4, 5, 6]
 
-**Algorithmic Steps:**
-
-This problem is solved with the help of **stack push & pop** to sort the elements in a particular order. The algorithmic approach can be summarized as follows:
-
-1. Accept the input stack as an argument to sort its elements.
- 
-2. Add a preliminary check by verifying the size of the stack less than one or not. If it is, just return from the function.
- 
-3. Create a stack implementation(i.e, `myStack`) based on array. It includes push, pop and peek operations.
+## Algorithm
 
-4. Create a temporary stack(`tempStack`) for storing the intermediate results inorder to calculate the sorted stack.
- 
-5. Iterate over the input stack `stack` until the elements exists in input stack.
- 
-6. For each iteration,
- 1. Get the top value of input stack and store it in `temp` variable.
- 2. Iterate over the temporary stack until it's size is greater than zero and the top value of temporary stack is greater than temp value.
- 3. For each above nested iteration, get the top element from temporary stack and push it to the input stack. This step helps to move higher values from temporary stack to insert lower values at the beginning.
- 4. If the condition of step2 is not satisfied, push the element to the temporary stack.
+This problem is solved using stack push and pop operations to sort the elements. The approach is as follows:
 
-7. Update the input stack with the elements of temporary stack to sort the elements in an ascending order.
+1. If the stack has less than one element, return immediately.
+2. Create a temporary stack (`tempStack`) to store intermediate results.
+3. While the input stack is not empty:
+ - Pop the top element from the input stack and store it in a variable `temp`.
+ - While `tempStack` is not empty and its top element is greater than `temp`:
+ - Pop from `tempStack` and push it back to the input stack.
+ - Push `temp` onto `tempStack`.
+4. Once done, transfer all elements from `tempStack` back to the input stack so that they are sorted in ascending order.
 
-**Time and Space complexity:**
 
-This algorithm has a time complexity of `O(n*2)`, where `n` is the number of elements in an array. This is because of traversal over the characters in a stack and temporary stack. 
+## Complexity
 
-Here, we used stack data structure store the sorted elements in a temporary stack. Hence, the space complexity will be `O(n)`.
+- **Time Complexity:** O(n²) in the worst case, due to nested stack operations.
+- **Space Complexity:** O(n), for the auxiliary stack.

src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.js

@@ -1,48 +1,45 @@
 class MyStack {
-
  constructor() {
- this.array = []; // Array is used to implement stack
+ this.items = [];
  }
 
- // List of main functions of stack data structure
-
+ // Core stack operations
  push(value) {
- // push an element into the array
- this.array.push(value);
+ this.items.push(value);
  }
 
  pop() {
- // Underflow if stack is empty
  if (this.isEmpty()) {
- return "Underflow";
+ throw new Error("Stack Underflow: Cannot pop from an empty stack.");
  }
-
- return this.array.pop(); // return top most element from the stack and removes the same element
+ return this.items.pop();
  }
 
  peek() {
- return this.array[this.array.length - 1]; // return top most element from the stack without removing the element
+ if (this.isEmpty()) {
+ throw new Error("Stack Underflow: Cannot peek from an empty stack.");
+ }
+ return this.items[this.items.length - 1];
  }
 
- // List of helper functions
-
+ // Helper functions
  isEmpty() {
- return this.array.length === 0; // return true if stack is empty
+ return this.items.length === 0;
  }
 
- printStack() {
- let data = "";
- for (let el of this.array)
- data += el + " ";
- return data;
+ size() {
+ return this.items.length;
  }
 
+ printStack() {
+ return this.items.join(' ');
+ }
 }
 
-function hasBalancedParentheses(characters) {
+function hasBalancedParentheses1(characters) {
  const myStack = new MyStack();
  if(characters.length === 0) return true;
- if(characters.length === 1 || characters.length % 2 !== 0) return false;
+ if(characters.length % 2 !== 0) return false;
 
  for(const ch of characters) {
  switch(ch) {
@@ -85,13 +82,48 @@ function hasBalancedParentheses(characters) {
  if(myStack.isEmpty()) return true;
 }
 
-let str1 = '()[]{}<>';
-let str2 = '[({<>})]';
-let str3 = '([)]';
+function hasBalancedParentheses2(input) {
+ const stack = new MyStack();
+ const bracketMap = {
+ ')': '(',
+ '}': '{',
+ ']': '[',
+ '>': '<'
+ };
+ const openBrackets = new Set(['(', '{', '[', '<']);
+
+ for (const ch of input) {
+ if (openBrackets.has(ch)) {
+ stack.push(ch);
+ } else if (ch in bracketMap) {
+ if (stack.pop() !== bracketMap[ch]) {
+ return false;
+ }
+ }
+ }
+ return stack.isEmpty();
+}
+
+// Test cases
+const testCases = [
+ { input: '()[]{}<>', expected: true },
+ { input: '[({<>})]', expected: true },
+ { input: '([)]', expected: false },
+ { input: '', expected: true },
+ { input: '(', expected: false },
+];
+
+for (const { input, expected } of testCases) {
+ const result = hasBalancedParentheses1(input);
+ console.log(`Input: "${input}" => ${result} (Expected: ${expected})`);
+}
+
+console.log("--------------------------------");
 
-console.log(hasBalancedParentheses(str1));
-console.log(hasBalancedParentheses(str2));
-console.log(hasBalancedParentheses(str3));
+for (const { input, expected } of testCases) {
+ const result = hasBalancedParentheses2(input);
+ console.log(`Input: "${input}" => ${result} (Expected: ${expected})`);
+}
 
 
 

src/javascript/algorithms/stack/2.balancedBrackets/balancedBrackets.md

@@ -1,44 +1,46 @@
-**Description:**
-Given a string `str` which contains the characters '(', ')', '{', '}', '[' and ']'. Determine whether an input string is valid or not by following the below conditions,
+# Balanced Brackets
 
-1. Open brackets must be closed by the same type of brackets in the correct order.
-2. Each close bracket has a respective open bracket of the same type.
+Balanced brackets is a classic problem that checks whether every opening bracket in a string has a corresponding and correctly ordered closing bracket. This is commonly used in parsing expressions, validating code, and more.
 
-## Examples:
-Example 1
-Input: str = [()[]{}<>] 
-Output: true
+The problem supports the following bracket types: `()`, `{}`, `[]`, `<>`.
 
+## Problem Statement
 
-Example 2
-Input: str = '[({<>})]'
-Output: true
+Given a string `str` containing the characters '(', ')', '{', '}', '[', ']', '<', and '>', determine whether the input string is valid. A string is valid if:
 
-Example 3
-Input: str = '([)]'
-Output: false
+1. Every open bracket is closed by the same type of bracket.
+2. Brackets are closed in the correct order.
 
+## Examples
 
-**Algorithmic Steps:**
+**Example 1** 
+Input: `str = "()[]{}<>"` 
+Output: `true`
 
-This problem is solved with the help of **stack push and pop** operations to determine the string has valid brackets or not. The algorithmic approach can be summarized as follows:
+**Example 2** 
+Input: `str = "[({<>})]"` 
+Output: `true`
 
-1. Add preliminary conditions for empty strings, string with one character and odd length. Return `true` if the string is empty and return `false` if the string has one character or length of the string is odd.
- 
-2. Create a stack implementation(i.e, `myStack`) based on array. It includes push, pop and peek operations.
- 
-3. Iterate over the input string `characters` and verify each character with the conditions of switch block.
- 
-4. If the character is an opening bracket(`([{<`), push it to the stack. 
+**Example 3** 
+Input: `str = "([)]"` 
+Output: `false`
 
-5. If the character is a closing bracket(`>}])`), verify the top element of stack equals to respective opening bracket or not. If so, remove/pop the element to indicate the match. Otherwise, return `false` indicating that the given string is not a balanced.
+## Algorithm
 
-6. Repeat steps 4-5 until the end of the string.
+This problem is solved using stack operations(**push and pop**) to track opening brackets and ensure they are closed in the correct order.
 
-7. Return `false` if the stack is not empty. That means, there are still few characters which are not balanced.
+1. If the string is empty, return `true`.
+2. If the string has an odd length, return `false` (since brackets must come in pairs).
+3. Initialize an empty stack.
+4. Iterate over each character in the string:
+ - If the character is an opening bracket (`(`, `{`, `[`, `<`), push it onto the stack.
+ - If the character is a closing bracket (`)`, `}`, `]`, `>`):
+ - If the stack is empty or the top of the stack does not match the corresponding opening bracket, return `false`.
+ - Otherwise, pop the top element from the stack.
+5. After processing all characters, return `true` if the stack is empty (all brackets matched); otherwise, return `false`.
 
-**Time and Space complexity:**
 
-This algorithm has a time complexity of `O(n)`, where `n` is the number of characters in a string. This is because traversal over the characters in a string at most once. 
+## Complexity
 
-Here, we used stack data structure store the opening brackets. In the worst case, the input string may contain only opening brackets. Hence, the space complexity will be O(n).
+- **Time Complexity:** O(n), where n is the length of the string. This is because of traversal over the characters in a string at most once.
+- **Space Complexity:** O(n), for the stack in the worst case (all opening brackets).