前面一部分学习的是括号匹配和后缀表达式的计算,后缀表达式是没有括号的,每遇到一个运算符就弹出两个元素计算。那么如果遇到含有括号/各种优先级的中缀表达式,如何运算呢?当然还是离不开栈的应用啦。
Leetcode 224. Basic Calculator (基础计算器)
Implement a basic calculator to evaluate a simple expression string.
The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .
You may assume that the given expression is always valid.
Some examples:
"1 + 1" = 2
" 2-1 + 2 " = 3
"(1+(4+5+2)-3)+(6+8)" = 23
题目解析:
这一题只是混合了括号和加减号(+-),加入乘除法(*/)的话只是使优先级判断更复杂些,不影响整体算法思路。
四则运算的规则是:(1)先乘除,后加减;(2)从左算到右(3)先括号内,后括号外
为实现该算法,我们需要使用两个工作栈。一个称作OPT,用以寄存运算符;另一个称作NUM,用以寄存操作数或运算结果。其算法基本思路是,(1)首先置操作数栈和操作符栈为空栈;
(2)依次读入表达式中的每个字符,若是操作数则进NUM栈,若是运算符则和OPT栈的栈顶运算符比较优先权后作相应操作。
最难懂最关键的是第二步,1.若该运算符优先权大于栈顶运算符优先权则该运算符直接进OPT栈;反之若运算符优先权小于栈顶运算符的优先权,则弹出栈顶运算符,并从操作数NUM栈弹出两个数进行该栈顶运算符的运算,运算结果再加入NUM操作数栈。 2.循环往复地进行第1步判断。直到将该操作符加入OPT操作符栈
(3)表达式读取结束,若两个栈都不为空,则依次弹出OPT栈中的运算符和NUM栈中的两个操作数,进行运算后,将运算结果在加入NUM栈。直到OPT栈为空,NUM栈只剩下一个元素,则该元素就是运算结果。
(4)中间出现差错,比如最后NUM栈剩下不止一个数,则视为表达式出错。
其中关键的第二步的关键是优先级的明确,基本就是按照四则运算的规则。这以复杂的问题就先不贴代码了,有时间再更新。
对于这一道题,解决方法略微简单,主要理解的是用栈的结构处理遇到括号时的办法。栈用来存储括号外的结果和符号,理解这一思想。
class Solution:
def calculate(self, s):
"""
:type s: str
:rtype: int
"""
stack = []
l = len(s)
i = 0
sgn,res = 1, 0 # 初始化res和符号变量sgn 存储前一个符号
while i <= l-1: # 遍历s
ch = s[i]
if ch ==' ':
i += 1
elif ch.isdigit(): # 处理遇到的数字(只可处理整数,其他的自行修改)
j = i
while j <= l-1:
j += 1
if j==l or not s[j].isdigit():
break
num = int(s[i:j]) # 此时的操作数为num
i = j
elif ch =='+' or ch == '-': # 遇到符号,对前面的结果进行计算
res += sgn * num
sgn = 1 if ch=='+' else -1 # 更新符号变量 sgn
i += 1
num = 0
elif ch == '(': # 左括号,将当前结果和符号 压入栈中
stack.append(res)
stack.append(sgn)
sgn,res = 1, 0 # 重置res和sgn
i += 1
elif ch == ')':
res += sgn*num # 遇到右括号,对前面的结果进行计算
res *= stack.pop() # 并取出栈中存储的res和sgn
res += stack.pop()
i += 1
num = 0 # 注意重置num=0 ,否则右括号后面第一个运算符会重复计算num
if num!= 0: # 如果此时num不为0 继续计算
res += sgn*num
return res
下面这一题仍然与括号的匹配有关,括号互相嵌套,必然是递归的思想,也是栈的重要应用。
385. Mini Parser (迷你解析器)
Given a nested list of integers represented as a string, implement a parser to deserialize it.
Each element is either an integer, or a list -- whose elements may also be integers or other lists.
Note: You may assume that the string is well-formed:
String is non-empty.
String does not contain white spaces.
String contains only digits 0-9
, [
, -
,
, ]
.
Example 1:
Given s = "324",You should return a NestedInteger object which contains a single integer 324.
Example 2:
Given s = "[123,[456,[789]]]",Return a NestedInteger object containing a nested list with 2 elements:
1. An integer containing value 123.
2. A nested list containing two elements:
i. An integer containing value 456.
ii. A nested list with one element:
a. An integer containing value 789.
题目解析:
此题开始读一两遍可能读不懂,事实上,我以为,题目叙述的也不严谨(或许是英语不好),理解之后就会明白本质上是一个括号匹配的问题,所以还是好好做一下这道题,把这一类问题理解了。
该题的答案大概两个版本,一是利用eval()函数,十分方便,二是挨个字符遍历。但是解决问题的本质是利用函数递归解析括号内的对象(括号内再有括号),利用了内存中函数调用栈,故我们见不到栈,但是算法思想是栈。
方法一:
def deserialize(self, s):
def nestedInteger(x):
if isinstance(x, int):
return NestedInteger(x)
lst = NestedInteger()
for y in x:
lst.add(nestedInteger(y))
return lst
return nestedInteger(eval(s))
方法二:
class Solution:
def deserialize(self, s):
"""
:type s: str
:rtype: NestedInteger
"""
def nestedInteger():
num = ''
while s[-1] in '1234567890-':
num += s.pop()
if num:
return NestedInteger(int(num))
s.pop() # 此为左括号
print('out',s)
lst = NestedInteger()
while s[-1] != ']': # 遍历当前[]内的每一个元素(数字或list),遇到‘,’去掉
lst.add(nestedInteger())
print('loop',s)
if s[-1] == ',':
s.pop()
s.pop() # 此为右括号
return lst
还有一个一行代码的版本,要求我们熟悉匿名函数那一套理论,reduce函数以及 if-else语句,难懂==
def deserialize(self, s):
return NestedInteger(s) if isinstance(s, int) else reduce(lambda a, x: a.add(self.deserialize(x)) or a, s, NestedInteger()) if isinstance(s, list) else self.deserialize(eval(s))
看这一篇博客可理解递归的实现和栈的关系,数据结构之---栈和递归&函数调用
方法一十分简洁易懂,通过eval()方法将字符串转换为列表对象,并遍历列表元素;方法二是遍历字符串,在这一方法中先将字符串s逆序,便于使用栈的pop方法,实际上还是自左向右遍历,先处理数字,若不是数字则是列表,思路与方法一相同,对应注释理解一下括号匹配的处理。方法二难懂可以自己过一遍,可以与方法一的步骤对比来看。