Merge pull request #45 from Jer3myYu/java-solutions-stacks

Java Chapter 7: Stacks

Author: Destiny-02

java/Stacks/EvaluateExpression.java

@@ -0,0 +1,48 @@
+import java.util.Stack;
+
+public class EvaluateExpression {
+    public int evaluateExpression(String s) {
+        Stack<Integer> stack = new Stack<>();  
+        int currNum = 0;
+        int sign = 1;
+        int res = 0;
+        for (char c : s.toCharArray()) {
+            if (Character.isDigit(c)) {
+                currNum = currNum * 10 + c - '0';
+            }
+            // If the current character is an operator, add 'currNum' to 
+            // the result after multiplying it by its sign.
+            else if (c == '+' || c == '-') {
+                res += currNum * sign;
+                // Update the sign and reset 'curr_num'.
+                sign = c == '-' ? -1 : 1;
+                currNum = 0;
+            }
+            // If the current character is an opening parenthesis, a new 
+            // nested expression is starting.
+            else if (c == '(') {
+                // Save the current 'res' and 'sign' values by pushing them 
+                // onto the stack, then reset their values to start 
+                // calculating the new nested expression.
+                stack.push(res);
+                stack.push(sign);
+                res = 0;
+                sign = 1;
+            }
+            // If the current character is a closing parenthesis, a nested 
+            // expression has ended.
+            else if (c == ')') {
+                // Finalize the result of the current nested expression.
+                res += sign * currNum;
+                // Apply the sign of the current nested  expression's result 
+                // before adding this result to the result of the outer 
+                // expression.
+                res *= stack.pop();
+                res += stack.pop();
+                currNum = 0;
+            }
+        }
+        // Finalize the result of the overall expression.
+        return res + currNum * sign;
+    }
+}

java/Stacks/ImplementAQueueUsingAStack.java

@@ -0,0 +1,37 @@
+import java.util.Stack;
+
+public class ImplementAQueueUsingAStack {
+    Stack<Integer> enqueueStack;
+    Stack<Integer> dequeueStack;
+
+    public ImplementAQueueUsingAStack() {
+        this.enqueueStack = new Stack<>();
+        this.dequeueStack = new Stack<>();
+    }
+
+    public void enqueue(int x) {
+        this.enqueueStack.push(x);
+    }
+
+    private void transferEnqueueToDequeue() {
+        // If the dequeue stack is empty, push all elements from the enqueue stack
+        // onto the dequeue stack. This ensures the top of the dequeue stack
+        // contains the most recent value.
+        if (this.dequeueStack.isEmpty()) {
+            while (!this.enqueueStack.isEmpty()) {
+                this.dequeueStack.push(enqueueStack.pop());
+            }
+        }
+    }
+
+    public int dequeue() {
+        transferEnqueueToDequeue();;
+        // Pop and return the value at the top of the dequeue stack.
+        return this.dequeueStack.isEmpty() ? null : this.dequeueStack.pop();
+    }
+
+    public int peek() {
+        transferEnqueueToDequeue();;
+        return this.dequeueStack.isEmpty() ? null : this.dequeueStack.peek();
+    }
+}

java/Stacks/MaximumsOfSlidingWindow.java

@@ -0,0 +1,34 @@
+import java.util.Stack;
+
+public class MaximumsOfSlidingWindow {
+    public int[] maximumsOfSlidingWindow(int[] nums, int k) {
+        int[] res = new int[nums.length - k + 1];
+        Stack<int[]> dq = new Stack<>();
+        int left, right;
+        left = right = 0;
+        while (right < nums.length) {
+            // 1) Ensure the values of the deque maintain a monotonic decreasing order
+            // by removing candidates <= the current candidate.
+            while (!dq.isEmpty() && dq.peek()[0] <= nums[right]) {
+                dq.pop();
+            }
+            // 2) Add the current candidate.
+            dq.push(new int[]{nums[right], right});
+            // If the window is of length 'k', record the maximum of the window.
+            if (right - left + 1 == k) {
+                // 3) Remove values whose indexes occur outside the window.
+                if (!dq.isEmpty() && dq.firstElement()[1] < left) {
+                    dq.remove(0);
+                }
+                // The maximum value of this window is the leftmost value in the 
+                // deque.
+                res[left] = dq.firstElement()[0];
+                // Slide the window by advancing both 'left' and 'right'. The right  
+                // pointer always gets advanced so we just need to advance 'left'.
+                left++;
+            }
+            right++;
+        }
+        return res;
+    }
+}

java/Stacks/NextLargestNumberToTheRight.java

@@ -0,0 +1,22 @@
+import java.util.Stack;
+
+public class NextLargestNumberToTheRight {
+    public int[] nextLargestNumberToTheRight(int[] nums) {
+        int[] res = new int[nums.length];
+        Stack<Integer> stack = new Stack<>();
+        // Find the next largest number of each element, starting with the 
+        // rightmost element.
+        for (int i = nums.length - 1; i >= 0; i--) {
+            // Pop values from the top of the stack until the current 
+            // value's next largest number is at the top.
+            while (!stack.isEmpty() && stack.peek() <= nums[i]) {
+                stack.pop();
+            }
+            // Record the current value's next largest number, which is at 
+            // the top of the stack. If the stack is empty, record -1.
+            res[i] = stack.isEmpty() ? -1 : stack.peek();
+            stack.push(nums[i]);
+        }
+        return res;
+    }
+}

java/Stacks/RepeatedRemovalOfAdjacentDuplicates.java

@@ -0,0 +1,25 @@
+import java.util.Stack;
+
+public class RepeatedRemovalOfAdjacentDuplicates {
+    public String repeatedRemovalOfAdjacentDuplicates(String s) {
+        Stack<Character> stack = new Stack<>();
+        StringBuilder res = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            // If the current character is the same as the top character on the stack,
+            // a pair of adjacent duplicates has been formed. So, pop the top character 
+            // from the stack.
+            if (!stack.isEmpty() && c == stack.peek()) {
+                stack.pop();
+            }
+            // Otherwise, push the current character onto the stack.
+            else {
+                stack.push(c);
+            }
+        }
+        // Return the remaining characters as a string.
+        for (char c : stack) {
+            res.append(c);
+        }
+        return res.toString();
+    }
+}

java/Stacks/ValidParenthesisExpression.java

@@ -0,0 +1,32 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+public class ValidParenthesisExpression {
+    public boolean validParenthesisExpression(String s) {
+        Map<Character, Character> parenthesesMap = new HashMap<>();
+        Stack<Character> stack = new Stack<>();
+        parenthesesMap.put('(', ')');
+        parenthesesMap.put('{', '}');
+        parenthesesMap.put('[', ']');
+        for (char c : s.toCharArray()) {
+            // If the current character is an opening parenthesis, push it 
+            // onto the stack.
+            if (parenthesesMap.containsKey(c)) {
+                stack.push(c);
+            }
+            // If the current character is a closing parenthesis, check if 
+            // it closes the opening parenthesis at the top of the stack.
+            else {
+                if (!stack.isEmpty() && parenthesesMap.get(stack.peek()) == c) {
+                    stack.pop();
+                } else {
+                    return false;
+                }
+            }
+        }
+        // If the stack is empty, all opening parentheses were successfully 
+        // closed.
+        return stack.isEmpty();
+    }
+}