本章开始栈与队列的刷题了
栈与队列的基本概念见我的另一篇文章《栈和队列在python中的实现》https://blog.csdn.net/qq_42368281/article/details/123847239
20.有效的括号
给定一个只包括 ‘(’,‘)’,‘{’,‘}’,‘[’,‘]’ 的字符串 s ,判断字符串是否有效。
有效字符串需满足:
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例:
输入:s = “([)]”
输出:false
输入:s = “()[]{}”
输出:true
题解
因为括号匹配是后遇到的左括号要先闭合,所以可以想到 栈 的策略就是后进先出,可以使用栈来解决该问题。
举例来说,遍历给定的字符串 ss:
当我们遇到一个左括号时,我们会期望在后续的遍历中,有一个相同类型的右括号将其闭合,因此我们可以将这个左括号放入栈顶。当我们遇到一个右括号时,我们需要将一个相同类型的左括号闭合。此时,我们可以取出栈顶的左括号并判断它们是否是相同类型的括号。如果不是相同的类型,或者栈中并没有左括号,那么字符串 ss 无效,返回 False。
在遍历结束后,如果栈中没有左括号,说明我们将字符串 ss 中的所有左括号闭合,返回 True,否则返回 False。
同时显而易见,有效字符串的长度一定为偶数,因此如果字符串的长度为奇数,我们可以直接返回 False,省去后续的遍历判断过程。
为了快速判断括号的类型,我们也可以使用哈希表存储每一种括号。哈希表的键为右括号,值为相同类型的左括号。
class Solution:
def isValid(self, s: str) -> bool:
if len(s) % 2 == 1:
return False
stack = []
mapping = {
'(': ')',
'[': ']',
'{': '}'
}
for item in s:
if item in mapping.keys():
stack.append(mapping[item])
elif not stack or stack[-1] != item:
return False
else:
stack.pop()
return True if not stack else False
1047.删除字符串中的所有相邻重复项
给出由小写字母组成的字符串 S(S仅由小写字母组成),重复项删除操作会选择两个相邻且相同的字母,并删除它们。
在 S 上反复执行重复项删除操作,直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
示例:
输入:“abbaca”
输出:“ca”
解释:
例如,在 “abbaca” 中,我们可以删除 “bb” 由于两字母相邻且相同,这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”,其中又只有 “aa” 可以执行重复项删除操作,所以最后的字符串为 “ca”。
题解
我们可以发现,当字符串中同时有多组相邻重复项时,我们无论是先删除哪一个,都不会影响最终的结果。因此我们可以从左向右顺次处理该字符串。
而消除一对相邻重复项可能会导致新的相邻重复项出现,如从字符串 abba 中删除bb 会导致出现新的相邻重复项 aa 出现。因此我们需要保存当前还未被删除的字符。一种显而易见的数据结构呼之欲出:栈。我们只需要遍历该字符串,如果当前字符和栈顶字符相同,我们就贪心地将其消去,否则就将其入栈即可。
class Solution:
def removeDuplicates(self, s: str) -> str:
stk = list()
for ch in s:
if stk and stk[-1] == ch:
stk.pop()
else:
stk.append(ch)
return "".join(stk)
150.逆波兰表达式求值
根据 逆波兰表示法,求表达式的值。
注意 两个整数之间的除法只保留整数部分。
可以保证给定的逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1:
输入:tokens = ["2","1","+","3","*"]
输出:9
解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9
示例 2:
输入:tokens = ["4","13","5","/","+"]
输出:6
解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6
示例 3:
输入:tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出:22
解释:该算式转化为常见的中缀算术表达式为:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
题解:
【逆波兰式(Reverse Polish notation,或逆波兰记法),也叫后缀表达式(将运算符写在操作数之后).一个表达式E的后缀形式可以如下定义:
(1)如果E是一个变量或常量,则E的后缀式是E本身。
(2)如果E是E1 op E2形式的表达式,这里op是任何二元操作符,则E的后缀式为E1’E2’ op,这里E1’和E2’分别为E1和E2的后缀式。
(3)如果E是(E1)形式的表达式,则E1的后缀式就是E的后缀式。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。】
我们平时见到的运算表达式是中缀表达式,即 “操作数① 运算符② 操作数③” 的顺序,运算符在两个操作数中间。
但是后缀表达式是 “操作数① 操作数③ 运算符②” 的顺序,运算符在两个操作数之后。
各种表达式没有本质区别,他们其实是同一个语法树,只是遍历方式不同而得到的不同式子;是一个事物的一体多面,只不过是从不同角度观察罢了。
- 中缀表达式是其对应的语法树的中序遍历(左根右);
- 后缀表达式是其对应的语法树的后序遍历(左右根);
- 前缀表达式是其对应的语法树的前序遍历(根左右);
下图中左边是中缀表达式,中间是其对应的语法树,右边是语法树转成的后缀表达式。
求解方法
对逆波兰表达式求值的过程是:
- 如果遇到数字就进栈;
- 如果遇到操作符,就从栈顶弹出两个数字分别为 num2(栈顶)、num1(栈中的第二个元素);计算 num1 运算 num2 .
逆波兰表达式是的代码实现很方便,用一个栈就能解决。
躲坑指南
本题对 Python 而言,有坑。
坑一:
Python 中没有一个函数可以判断一个字符串是否为合理的整数(包括正、负数)。str.isdigit() 可以判断正数,但是无法判断负数。
解决方法
使用 int() 函数,并做 try-except 。
如果是整数,那么可以用 int() 转成数字;
如果是运算符,那么 int() 会报错,从而进入 except 中。
try:
stack.append(int(token))
except:
pass # 处理运算符
坑二:
python 的整数除法是向下取整,而不是向零取整。
- python2 的除法 “/” 是整数除法, “-3 / 2 = -2” ;
- python3 的地板除 “//” 是整数除法, “-3 // 2 = -2” ;
- python3 的除法 “/” 是浮点除法, “-3 / 2 = -1.5” ;
而 C++/Java 中的整数除法是向零取整。
C++/Java 中 “-3 / 2 = -1” .
本题的题意(一般情况)都是要求向零取整的。
from typing import List
from typing import List
class Solution:
def evalRPN(self, tokens: List[str]) -> int:
op_to_binary_fn = {
"+": lambda x, y: x + y,
"-": lambda x, y: x - y,
"*": lambda x, y: x * y,
"/": lambda x, y: int(x / y), # 需要注意 python 中负数除法的表现与题目不一致
}
stack = list()
for token in tokens:
try:
num = int(token)
except ValueError:
num2 = stack.pop()
num1 = stack.pop()
num = op_to_binary_fn[token](num1, num2)
finally:
stack.append(num)
return stack[0]
时间复杂度:O(n),其中 n 是数组 tokens 的长度。需要遍历数组 tokens 一次,计算逆波兰表达式的值。
空间复杂度:O(n),其中 n 是数组 tokens 的长度。使用栈存储计算过程中的数,栈内元素个数不会超过逆波兰表达式的长度。