LeetCode - 150. Evaluate Reverse Polish Notation

LeetCode - 150. Evaluate Reverse Polish Notation

在计算机科学领域，表达式求值是一个基础且重要的问题，而逆波兰表达式（也称为后缀表达式）以其独特的结构和高效的求值方式，在编译器设计、计算器程序等场景中广泛应用。LeetCode 第 150 题 “Evaluate Reverse Polish Notation” 正是围绕逆波兰表达式求值展开，本题不仅考查对数据结构的运用，还考验开发者处理逻辑和边界情况的能力。接下来，我们就深入剖析这道题目，通过 JavaScript 和 Python 两种语言的代码实现，探索其解题思路与细节。

1. 问题描述深度解读

1.1 逆波兰表达式的定义

逆波兰表达式是一种将运算符置于操作数之后的表达式表示方法。与我们日常熟悉的中缀表达式（如 3 + 4）不同，逆波兰表达式 3 4 + 更便于计算机进行处理。它消除了运算符优先级和括号的困扰，通过特定的规则即可完成求值，是计算机高效处理表达式的重要方式。

1.2 题目具体要求

• 输入：一个字符串数组 tokens，其中每个元素要么是一个数字（以字符串形式表示），要么是一个运算符（"+"、"-"、"*"、"/"），构成了一个逆波兰表达式。
• 输出：对输入的逆波兰表达式进行求值后得到的最终结果，以数字形式返回。

例如，输入 ["2", "1", "+", "3", "*"]，该表达式对应的中缀表达式为 (2 + 1) * 3，经过计算，输出应为 9。

2. 解题思路与核心逻辑剖析

2.1 栈的妙用

解决逆波兰表达式求值问题的核心数据结构是栈。栈是一种遵循 “后进先出（LIFO）” 原则的数据结构，这一特性与逆波兰表达式的求值逻辑高度契合。其解题的关键点在于：

• 当遇到数字（变量）时，将其转换为数字类型后压入栈中。因为在后续的运算中，这些数字将作为操作数参与计算。
• 当遇到运算符时，从栈顶依次弹出两个元素作为操作数，根据运算符进行相应的运算，再将运算结果压回栈中。如此循环，直到遍历完整个表达式数组。
• 最后，当表达式扫描结束后，栈中剩下的唯一元素就是整个逆波兰表达式的求值结果。

2.2 具体解题步骤

• 步骤 a：构建栈：初始化一个空栈，用于存储操作数和中间计算结果。在 JavaScript 中可以使用数组模拟栈，如 let stack = []；在 Python 中同样可以使用列表，如 stack = []。
• 步骤 b：求解：
• 1. 遍历输入的逆波兰表达式数组 tokens。
• 2. 对于每个元素 token，判断其是否为数字。在 JavaScript 中，通过 Number(token) 将字符串转换为数字，并使用 isNaN(t) 来判断转换后的结果是否为 NaN（即非数字）；在 Python 中，通过判断 token 是否为运算符，若不是则将其转换为整数压入栈，如 stack.append(int(token))。
• 3. 如果 token 是运算符，则从栈顶弹出两个元素作为操作数（注意弹出顺序，后弹出的是第一个操作数，先弹出的是第二个操作数），根据运算符进行相应运算，并将结果压回栈中。例如，遇到 "+" 运算符时，在 JavaScript 中执行 stack.push(n2 + n1)，在 Python 中执行 stack.append(n2 + n1) 。
• 4. 重复上述步骤，直到遍历完整个 tokens 数组。
• 5. 最终，栈中剩下的唯一元素就是逆波兰表达式的求值结果，直接返回该元素即可。

3. JavaScript 代码实现与逐行解析

/**
 * @param {string[]} tokens
 * @return {number}
 */
var evalRPN = function (tokens) {
    let stack = []
    for (let token of tokens) {
        let t = Number(token);
        if (isNaN(t)) {
            let n1 = stack.pop();
            let n2 = stack.pop();
            switch (token) {
                case '+':
                    stack.push(n2 + n1);
                    break;
                case '-':
                    stack.push(n2 - n1);
                    break;
                case '*':
                    stack.push(n2 * n1);
                    break;
                case '/':
                    let d = n2 / n1;
                    if (d < 0) {
                        d = - Math.floor(-d);
                    }else{
                        d = Math.floor(d);
                    }
                    stack.push(d);
                    break;
            }
        } else {
            stack.push(t);
        }
    }
    return stack[0];
};

• 首先，创建一个空数组 stack 用于模拟栈。
• 然后，通过 for...of 循环遍历输入的 tokens 数组。对于每个元素 token：
  • 将 token 转换为数字 t，并使用 isNaN(t) 判断是否为数字。如果 isNaN(t) 返回 true，说明 token 是运算符：
    • 从栈顶弹出两个元素 n1 和 n2 作为操作数。
    • 使用 switch 语句根据不同的运算符进行相应的运算，并将结果压回栈中。特别要注意除法运算，题目要求为整除，且需处理负数整除的情况。当 d < 0 时，通过 d = -Math.floor(-d) 实现向零取整的整除；当 d >= 0 时，直接使用 Math.floor(d) 进行向下取整。
  • 如果 isNaN(t) 返回 false，说明 token 是数字，直接将其压入栈中。
• 循环结束后，栈中剩下的唯一元素就是表达式的求值结果，通过 return stack[0] 返回。

4. Python 代码实现与详细解读

class Solution:
    def evalRPN(self, tokens) -> int:
        stack = []
        for token in tokens:
            if token == '+':
                n1 = stack.pop()
                n2 = stack.pop()
                stack.append(n2 + n1)
            elif token == '-':
                n1 = stack.pop()
                n2 = stack.pop()
                stack.append(n2 - n1)
            elif token == '*':
                n1 = stack.pop()
                n2 = stack.pop()
                stack.append(n2 * n1)
            elif token == '/':
                n1 = stack.pop()
                n2 = stack.pop()
                if n2 // n1 < 0:
                    stack.append(-(abs(n2) // abs(n1)))
                else:
                    stack.append(n2 // n1)
            else:
                stack.append(int(token))
            
        return stack[0]

• 在 evalRPN 方法中，首先初始化一个空列表 stack 作为栈。
• 接着，使用 for 循环遍历 tokens 列表。对于每个元素 token：
  • 判断 token 是否为运算符。如果是 "+" 运算符，从栈顶弹出两个元素 n1 和 n2，计算它们的和并将结果压回栈中；如果是 "-" 运算符，计算两数之差并压回栈；如果是 "*" 运算符，计算乘积并压回栈；如果是 "/" 运算符，同样弹出两个元素进行除法运算，注意处理负数整除情况，当 n2 // n1 < 0 时，通过 -(abs(n2) // abs(n1)) 实现向零取整的整除，否则直接使用 n2 // n1 进行整除，并将结果压回栈。
  • 如果 token 不是运算符，则将其转换为整数后压入栈中。
• 循环结束后，栈中剩下的唯一元素即为表达式的求值结果，通过 return stack[0] 返回。

5. 关键细节与注意事项

5.1 负数整除的处理

在除法运算中，题目明确要求为整除，并且需要正确处理负数整除的情况。无论是 JavaScript 还是 Python，都不能简单地使用常规的除法运算符。在 JavaScript 中，通过 Math.floor 结合条件判断实现向零取整；在 Python 中，使用 // 整除运算符，并根据结果的正负进行特殊处理，确保结果符合题目要求。

5.2 栈操作的顺序

在从栈中弹出操作数时，要严格遵循 “后进先出” 的原则，后弹出的元素作为第一个操作数，先弹出的元素作为第二个操作数。否则，会导致运算顺序错误，得出错误的结果。

6. 示例演示与执行过程分析

以输入 ["2", "1", "+", "3", "*"] 为例：

• 1. 遍历到 "2"，是数字，将 2 压入栈，此时栈为 [2]。
• 2. 遍历到 "1"，是数字，将 1 压入栈，此时栈为 [2, 1]。
• 3. 遍历到 "+"，是运算符，从栈顶弹出 1 和 2，计算 2 + 1 = 3，将结果 3 压入栈，此时栈为 [3]。
• 4. 遍历到 "3"，是数字，将 3 压入栈，此时栈为 [3, 3]。
• 5. 遍历到 "*"，是运算符，从栈顶弹出 3 和 3，计算 3 * 3 = 9，将结果 9 压入栈，此时栈为 [9]。
• 6. 遍历结束，栈中唯一元素 9 即为最终结果。

逆波兰表达式求值问题通过巧妙运用栈这一数据结构，将复杂的表达式求值过程转化为简单的栈操作，展现了数据结构与算法结合的精妙之处。通过 JavaScript 和 Python 两种语言的实现，我们不仅掌握了该问题的解决方案，还能对比不同语言在处理相同逻辑时的语法差异和编程习惯。在实际编程中，类似的思路和方法可以应用于更多与表达式处理相关的场景。同时，对于负数整除等细节的处理，也提醒我们在解决算法问题时要充分考虑各种边界情况，确保代码的准确性和健壮性。希望本文能帮助你深入理解逆波兰表达式求值问题，在算法学习和编程实践中更上一层楼。