这里所谓的前缀,中缀,后缀是根据操作符的位置来定的,
如果操作符在操作数前面,则称为前缀表达式,例如“- + 1 × + 2 3 4 5”;如果操作符在操作数之间,则称为中缀表达式,例如
“1+((2+3)×4)-5”;如果操作符在操作数后面,则称为后缀表达式,例如“1 2 3 + 4 × + 5 -”。
原因:
虽然中缀表达式符合人类的日常思维习惯,但是计算机在存储中缀表达式时,需要使用树这种数据结构,如果表达式过于复杂,那么树的高度会变得很高,大大增加了时间复杂度和空间复杂度。如果转换成线性结构,那么效率将变得高很多,所以需要将中缀表达式先转换成前缀或者后缀表达式,然后依靠栈这种线性数据结构来进行计算。
介绍:
前缀表达式又叫波兰表达式,后缀表达式又叫逆波兰表达式。前缀表达式基本没有在商业计算机中使用过,所以现实中用的更多的是后缀表达式。
转换方法:
第一种方法:加括号法
前缀:把符号放在本级的括号前。 后缀:把符号放在本级的括号后。
如中缀表达式加括号后:(3+((4*(5-3))/(4-2))),同级符号从左至右加括号
把符号放在本级的括号前:+(3/(*(4-(53))-(42)))
去掉括号,前缀表达式即:+3/*4-53-42
把符号放在本级的括号前:(3((4(53)-)*(42)-)/)+
去掉括号,后缀表达式即:3453-*42-/+
第二种方法:堆栈法
代码编写如下
中 ------> 后
简单规则:优先级先乘除再加减,入栈方向从左往右,栈外的符号想进栈,栈内的符号想出栈。栈外右括号不能进栈,栈外左括号优先级最高。栈内左括号优先级最低。
1、利用两个栈S1,S2:其中S1存放操作符,S2存放操作数。
2、从左往右遍历中缀表达式,如果遇到数字,则放入S2中,如果遇到操作符,则放入S1中。
3、在放操作符的时候有一定的规则:(1)如果栈为空,则直接压栈;如果要入栈的是左括号(,则直接压栈;如果栈顶是左括号(,则直接压栈。(2)如果遇到右括号),则依次弹出S1栈顶的运算符,并压入S2,直到遇到左括号(为止,此时将这一对括号丢弃。(3)如果栈顶元素为普通操作符,则比较优先级,如果待压栈的操作符比栈顶操作符优先级高,则直接压栈,否则将S1中的栈顶元素出栈,并压入S2中,再接着比较S1栈顶元素的优先级,注意在最近的左括号之前的范围。(4)最后将S1中剩余的运算符依次弹出并压入S2,逆序输出S2(从栈底到栈顶)便得到了后缀表达式。(注意:等号的优先级最低,因为要到最后才进行赋值操作)
# coding:utf-8
def priority(z):
if z in ['×', '*', '/']:
return 2
elif z in ['+', '-']:
return 1
def in2post(expr):
""" :param expr: 中缀表达式
:return: 后缀表达式
Example:
"1+((2+3)×4)-5"
"1 2 3 + 4 × + 5 -"
"""
stack = [] # 存储栈
post = [] # 后缀表达式存储
for z in expr:
if z not in ['×', '*', '/', '+', '-', '(', ')']: # 非操作符直接进数字栈
post.append(z)
print(1, post)
else: # 如果是操作符
if z != ')' and (not stack or z == '(' or stack[-1] == '('
or priority(z) > priority(stack[-1])): # 第一类:stack 为空;栈顶为(;要入栈的是(;优先级大于
stack.append(z) # 操作符入栈
elif z == ')': # 第二类:如果是右括号,则出栈直至左括号
while True:
x = stack.pop()
if x != '(':
post.append(x)
print(2, post)
else:
break
else: # 第三类:比较运算符优先级,看是否入栈出栈
while True:
if stack and stack[-1] != '(' and priority(z) <= priority(stack[-1]): # 符号栈不为空,并且在括号范围内,并且优先级不大于当前栈顶符号
post.append(stack.pop())
print(3, post)
else:
stack.append(z)
break
while stack: # 表达式遍历完毕,但是还未出栈的运算符,需要加到表达式末尾
post.append(stack.pop())
return post
if __name__ == '__main__':
s = "1+((2+3)×4)-5"
post = in2post(s)
print('后缀表达式: ',post)
## 输出:
# 1 ['1']
# 1 ['1', '2']
# 1 ['1', '2', '3']
# 2 ['1', '2', '3', '+']
# 1 ['1', '2', '3', '+', '4']
# 2 ['1', '2', '3', '+', '4', '×']
# 3 ['1', '2', '3', '+', '4', '×', '+']
# 1 ['1', '2', '3', '+', '4', '×', '+', '5']
# 后缀表达式: ['1', '2', '3', '+', '4', '×', '+', '5', '-']
中 ------> 前
简单规则:优先级先乘除再加减,入栈方向从右往左,栈外的符号想进栈,栈内的符号想出栈。栈外左括号不能进栈,栈外右括号优先级最高。栈内右括号优先级最低。和上面不同的还在于比较优先级,大于等于直接进栈。
1、利用两个栈S1,S2:其中S1存放操作符,S2存放操作数。
2、从右往左遍历中缀表达式,如果遇到数字,则放入S2中,如果遇到操作符,则放入S1中。
3、在放操作符的时候有一定的规则:(1)如果栈为空,则直接压栈;如果要入栈的是右括号),则直接压栈;如果栈顶是右括号),则直接压栈。(2)如果遇到左括号(,则依次弹出S1栈顶的运算符,并压入S2,直到遇到右括号)为止,此时将这一对括号丢弃。(3)如果栈顶元素为普通操作符,则比较优先级,如果待压栈的操作符比栈顶操作符优先级高或者同级别,则直接压栈,否则将S1中的栈顶元素出栈,并压入S2中,再接着比较S1栈顶元素的优先级,注意在最近的右括号之前的范围。(4)最后将S1中剩余的运算符依次弹出并压入S2,顺序输出S2(从栈顶到栈底)便得到了前缀表达式。(注意:等号的优先级最低,因为要到最后才进行赋值操作)
# coding:utf-8
def priority(z):
if z in ['×', '*', '/']:
return 2
elif z in ['+', '-']:
return 1
def in2pre(expr):
""" :param expr: 中缀表达式
:return: 前缀表达式
Example:
"1+((2+3)×4)-5"
"- + 1 x + 2 3 4 5"
"""
stack = [] # 存储栈
pre = [] # 前缀表达式存储
for z in expr[::-1]: # 从右往左
if z not in ['×', '*', '/', '+', '-', '(', ')']: # 非操作符直接进数字栈
pre.append(z)
print(1, pre)
else: # 如果是操作符
if z != '(' and (not stack or z == ')' or stack[-1] == ')'
or priority(z) >= priority(stack[-1])): # 第一类:stack 为空;栈顶为);要入栈的是);优先级大于或等于
stack.append(z) # 操作符入栈
elif z == '(': # 第二类:如果是左括号,则出栈直至右括号
while True:
x = stack.pop()
if x != '(':
pre.append(x)
print(2, pre)
else:
break
else: # 第三类:比较运算符优先级,看是否入栈出栈
while True:
if stack and stack[-1] != ')' and priority(z) < priority(stack[-1]): # 符号栈不为空,并且在括号范围内,并且优先级小于当前栈顶符号
pre.append(stack.pop())
print(3, pre)
else:
stack.append(z)
break
while stack: # 表达式遍历完毕,但是还未出栈的运算符,需要加到表达式末尾
pre.append(stack.pop())
print('反转前表达式:',pre)
return pre[::-1]
if __name__ == '__main__':
s = "1+((2+3)×4)-5"
pre = in2pre(s)
print('前缀表达式: ',pre)
## 输出:
# 1 ['5']
# 1 ['5', '4']
# 1 ['5', '4', '3']
# 1 ['5', '4', '3', '2']
# 2 ['5', '4', '3', '2', '+']
# 2 ['5', '4', '3', '2', '+', '×']
# 3 ['5', '4', '3', '2', '+', '×', '1']
# 反转前表达式: ['5', '4', '3', '2', '+', '×', '1', '+', '-']
# 前缀表达式: ['-', '+', '1', 'x', '+', '2', '3', '4', '5']
计算机的计算方法:
得到后缀表达式之后,计算就变得方便多了,从左到右,遇到数字就压栈,遇到操作符的时候,pop出栈顶的两个元素,进行计算后将结果又压入栈中,这样一直下去,直到得到最终结果。
得到前缀表达式之后,计算就变得方便多了,从右到左,遇到数字就压栈,遇到操作符的时候,pop出栈顶的两个元素,进行计算后将结果又压入栈中,这样一直下去,直到得到最终结果。