update,

marissa.sam/task2/temp/_draft/helloworld copy 2.cpp

@@ -0,0 +1,123 @@
+#include <iostream>
+#include <stack>
+#include <cctype>
+#include <cstring>
+
+// 1. how to read and store the input?
+std::string readInput()
+{
+    std::string input;
+    char c;
+    while (std::cin.get(c)) {
+        if (c == '\n')
+            break;
+        input += c;
+    }
+    return input;
+}
+
+// 2. pseudo code of the algorithm
+// convert to postfix expression use stack, 
+// 1. if it is an operand, push it into stack, 
+// 2. if it is an operator,  pop the top two elements and push the operator result, 
+// 3. if it is a bracket, pop until the matched bracket, then push it into stack, 
+// 4. if the input is end, pop all the remaining elements, 
+// 5. if the last element is a bracket, return error, 
+// else return the result
+std::string infixToPostfix(const std::string& input)
+{
+    std::stack<char> stack;
+    std::string postfix;
+    const char* precedence = "+-*/()";
+    for (const auto& c : input) {
+        if (std::isalpha(c) || std::isdigit(c)) {
+            postfix += c;
+        } else if (c == '(') {
+            stack.push(c);
+        } else if (c == ')') {
+            while (!stack.empty() && stack.top() != '(') {
+                postfix += stack.top();
+                stack.pop();
+            }
+            if (!stack.empty()) {
+                stack.pop();
+            }
+        } else {
+            while (!stack.empty() && precedence[c] <= precedence[stack.top()]) {
+                postfix += stack.top();
+                stack.pop();
+            }
+            stack.push(c);
+        }
+    }
+    while (!stack.empty()) {
+        postfix += stack.top();
+        stack.pop();
+    }
+    return postfix;
+}
+
+// 3. data structures used in the algorithm
+// stack
+// string
+
+// 4. time complexity
+// O(n), where n is the length of input
+
+// 5. space complexity
+// O(n), where n is the length of input
+
+// 6. how to store the postfix expression?
+// using string
+
+int main()
+{
+    std::string input = readInput();
+    std::string postfix = infixToPostfix(input);
+    std::cout << postfix << std::endl;
+
+    // 1. how to read the postfix expression
+    // read postfix expression from standard input stream and store them into string
+
+    // 2. pseudo code of the algorithm
+    // evaluate a postfix expression use stack, 
+    // if it is an operand, push it into stack, 
+    // if it is an operator, pop the top two elements, apply the operator, and push the result, 
+    // if it is a bracket, pop until the matched bracket, then push it into stack, 
+    // if the input is end, return the last element in stack, 
+    // else error
+    std::stack<int> stack;
+    const char* operators = "+-*/";
+    for (const auto& c : postfix) {
+        if (std::isalpha(c) || std::isdigit(c)) {
+            stack.push(c - '0');
+        } else if (std::strchr(operators, c)) {
+            int operand2 = stack.top();
+            stack.pop();
+            int operand1 = stack.top();
+            stack.pop();
+
+            switch (c) {
+            case '+':
+                stack.push(operand1 + operand2);
+                break;
+            case '-':
+                stack.push(operand1 - operand2);
+                break;
+            case '*':
+                stack.push(operand1 * operand2);
+                break;
+            case '/':
+                stack.push(operand1 / operand2);
+                break;
+            default:
+                return -1;
+            }
+        } else {
+            return -1;
+        }
+    }
+    std::cout << stack.top() << std::endl;
+
+    return 0;
+}