Add C++ solutions for Chapter 7 (Stacks)

ongshunping · ongshunping · commit d5ae2f88afe2 · 2025-01-16T15:33:16.000+08:00
diff --git a/cpp/Stacks/evaluate_expression.cpp b/cpp/Stacks/evaluate_expression.cpp
@@ -0,0 +1,47 @@
+#include <string>
+#include <stack>
+
+int evaluateExpression(std::string s) {
+    std::stack<int> stack;
+    int currNum = 0, sign = 1, res = 0;
+    for (char c : s) {
+        if (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 'currNum'.
+            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.
+            int prevSign = stack.top(); stack.pop();
+            res *= prevSign;
+            int prevRes = stack.top(); stack.pop();
+            res += prevRes;
+            currNum = 0;
+        }
+    }
+    // Finalize the result of the overall expression.
+    return res + currNum * sign;
+}
diff --git a/cpp/Stacks/implement_a_queue_using_a_stack.cpp b/cpp/Stacks/implement_a_queue_using_a_stack.cpp
@@ -0,0 +1,48 @@
+#include <vector>
+#include <optional>
+
+class Queue {
+public:
+    Queue() {}
+
+    void enqueue(int x) {
+        enqueueStack.push_back(x);
+    }
+
+    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 (dequeueStack.empty()) {
+            while (!enqueueStack.empty()) {
+                dequeueStack.push_back(enqueueStack.back());
+                enqueueStack.pop_back();
+            }
+        }
+    }
+
+    std::optional<int> dequeue() {
+        transferEnqueueToDequeue();
+        // Pop and return the value at the top of the dequeue stack.
+        if (!dequeueStack.empty()) {
+            int val = dequeueStack.back();
+            dequeueStack.pop_back();
+            return val;
+        }
+        return std::nullopt;
+    }
+
+    std::optional<int> peek() {
+        transferEnqueueToDequeue();
+        // Return the value at the top of the dequeue stack without removing it.
+        if (!dequeueStack.empty()) {
+            return dequeueStack.back();
+        }
+        return std::nullopt; 
+    }
+
+private:
+    std::vector<int> enqueueStack;
+    std::vector<int> dequeueStack;
+
+};
diff --git a/cpp/Stacks/maximums_of_sliding_window.cpp b/cpp/Stacks/maximums_of_sliding_window.cpp
@@ -0,0 +1,32 @@
+#include <vector>
+#include <deque>
+
+std::vector<int> maximumsOfSlidingWindow(std::vector<int>& nums, int k) {
+    std::vector<int> res;
+    std::deque<std::pair<int, int>> dq;
+    int left = 0, right = 0;
+    while (right < nums.size()) {
+        // 1) Ensure the values of the deque maintain a monotonic decreasing order
+        // by removing candidates <= the current candidate.
+        while (!dq.empty() && dq.back().first <= nums[right]) {
+            dq.pop_back();
+        }
+        // 2) Add the current candidate.
+        dq.push_back(std::make_pair(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.empty() && dq.front().second < left) {
+                dq.pop_front();
+            }
+            // The maximum value of this window is the leftmost value in the 
+            // deque.
+            res.push_back(dq.front().first);
+            // 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;
+}
diff --git a/cpp/Stacks/next_largest_number_to_the_right.cpp b/cpp/Stacks/next_largest_number_to_the_right.cpp
@@ -0,0 +1,20 @@
+#include <vector>
+
+std::vector<int> nextLargestNumberToTheRight(std::vector<int>& nums) {
+    std::vector<int> res(nums.size(), 0);
+    std::vector<int> stack;
+    // Find the next largest number of each element, starting with the 
+    // rightmost element.
+    for (int i = nums.size() - 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.empty() && stack.back() <= nums[i]) {
+            stack.pop_back();
+        }
+        // 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.empty() ? stack.back() : -1;
+        stack.push_back(nums[i]);
+    }
+    return res;
+}
diff --git a/cpp/Stacks/repeated_removal_of_adjacent_duplicates.cpp b/cpp/Stacks/repeated_removal_of_adjacent_duplicates.cpp
@@ -0,0 +1,20 @@
+#include <string>
+#include <vector>
+
+std::string repeatedRemovalOfAdjacentDuplicates(std::string s) {
+    std::vector<char> stack;
+    for (char c : s) {
+        // 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.empty() && c == stack.back()) {
+            stack.pop_back();
+        }
+        // Otherwise, push the current character onto the stack.
+        else {
+            stack.push_back(c);
+        }
+    }
+    // Return the remaining characters as a string.
+    return std::string(stack.begin(), stack.end());
+}
diff --git a/cpp/Stacks/valid_parenthesis_expression.cpp b/cpp/Stacks/valid_parenthesis_expression.cpp
@@ -0,0 +1,28 @@
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+bool validParenthesisExpression(std::string s) {
+    std::unordered_map<char, char> parenthesesMap = {{'(', ')'}, {'{', '}'}, {'[', ']'}};
+    std::vector<char> stack;
+    for (char c : s) {
+        // If the current character is an opening parenthesis, push it 
+        // onto the stack.
+        if (parenthesesMap.find(c) != parenthesesMap.end()) {
+            stack.push_back(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.empty() && parenthesesMap[stack.back()] == c) {
+                stack.pop_back();
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    // If the stack is empty, all opening parentheses were successfully 
+    // closed.
+    return stack.empty();
+}
