逆波兰表达式求值

这段代码实现了一个用来计算逆波兰表达式（Reverse Polish Notation, RPN）的算法。逆波兰表达式是一种后缀表达式，操作符在操作数的后面。这个算法通过使用栈来逐步求值表达式中的操作数和操作符。

代码：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * @param tokens string字符串vector 
     * @return int整型
     */
    int evalRPN(vector<string>& tokens) {
        // 定义一个整数栈，用于存储操作数
        stack<int> stk;
        
        // 遍历所有的 tokens
        for(int i = 0; i < tokens.size(); ++i) {
            // 判断当前字符串是否为操作符
            if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
                // 获取栈顶的两个操作数
                int num1 = stk.top();
                stk.pop();
                int num2 = stk.top();
                stk.pop();
                
                // 根据操作符执行相应的计算
                if(tokens[i] == "+") 
                    stk.push(num2 + num1); // 加法
                else if(tokens[i] == "-") 
                    stk.push(num2 - num1); // 减法
                else if(tokens[i] == "*") 
                    stk.push(num2 * num1); // 乘法
                else 
                    stk.push(num2 / num1); // 除法
            }
            else {
                // 当前字符串是操作数，将其转换为整数后压入栈中
                stk.push(stoi(tokens[i]));
            }
        }
        
        // 最终栈顶的元素即为表达式的计算结果，返回该值
        return stk.top();
    }
};

代码流程总结

1. 定义一个整数栈 stk 用于存储操作数。
2. 遍历 tokens 中的每个字符串：
   • 如果当前字符串是操作符，弹出栈顶的两个操作数，进行相应的计算，将结果压入栈中。
   • 如果当前字符串是操作数，将其转换为整数并压入栈中。
3. 遍历结束后，栈中剩下的唯一一个元素就是表达式的结果，返回这个值。

示例

• 输入: tokens = ["2", "1", "+", "3", "*"]

  • 计算步骤：
    • 2 压栈
    • 1 压栈
    • + 取出 1 和 2，计算 2 + 1 = 3，结果 3 压栈
    • 3 压栈
    • * 取出 3 和 3，计算 3 * 3 = 9，结果 9 压栈
  • 输出: 9

• 输入: tokens = ["4", "13", "5", "/", "+"]

  • 计算步骤：
    • 4 压栈
    • 13 压栈
    • 5 压栈
    • / 取出 5 和 13，计算 13 / 5 = 2，结果 2 压栈
    • + 取出 2 和 4，计算 4 + 2 = 6，结果 6 压栈
  • 输出: 6