LeetCode - 150. Evaluate Reverse Polish Notation

本文介绍了一种通过栈来实现逆波兰表达式求值的方法。该方法适用于处理包含基本算术运算的逆波兰表达式,并能正确处理整除及负数情况。文章提供了JavaScript和Python两种语言的实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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
    1. 对于每个元素 token,判断其是否为数字。在 JavaScript 中,通过 Number(token) 将字符串转换为数字,并使用 isNaN(t) 来判断转换后的结果是否为 NaN(即非数字);在 Python 中,通过判断 token 是否为运算符,若不是则将其转换为整数压入栈,如 stack.append(int(token))
    1. 如果 token 是运算符,则从栈顶弹出两个元素作为操作数(注意弹出顺序,后弹出的是第一个操作数,先弹出的是第二个操作数),根据运算符进行相应运算,并将结果压回栈中。例如,遇到 "+" 运算符时,在 JavaScript 中执行 stack.push(n2 + n1),在 Python 中执行 stack.append(n2 + n1)
    1. 重复上述步骤,直到遍历完整个 tokens 数组。
    1. 最终,栈中剩下的唯一元素就是逆波兰表达式的求值结果,直接返回该元素即可。

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 是运算符:
      • 从栈顶弹出两个元素 n1n2 作为操作数。
      • 使用 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 是否为运算符。如果是 "+" 运算符,从栈顶弹出两个元素 n1n2,计算它们的和并将结果压回栈中;如果是 "-" 运算符,计算两数之差并压回栈;如果是 "*" 运算符,计算乘积并压回栈;如果是 "/" 运算符,同样弹出两个元素进行除法运算,注意处理负数整除情况,当 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]
    1. 遍历到 "1",是数字,将 1 压入栈,此时栈为 [2, 1]
    1. 遍历到 "+",是运算符,从栈顶弹出 12,计算 2 + 1 = 3,将结果 3 压入栈,此时栈为 [3]
    1. 遍历到 "3",是数字,将 3 压入栈,此时栈为 [3, 3]
    1. 遍历到 "*",是运算符,从栈顶弹出 33,计算 3 * 3 = 9,将结果 9 压入栈,此时栈为 [9]
    1. 遍历结束,栈中唯一元素 9 即为最终结果。

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿蒙Armon

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值