Python与数据结构[1] -> 栈/Stack[1] -> 中缀表达式与后缀表达式的转换和计算

中缀表达式与后缀表达式的转换和计算

---

目录

1. 中缀表达式转换为后缀表达式
2. 后缀表达式的计算

1 中缀表达式转换为后缀表达式

中缀表达式转换为后缀表达式的实现方式为：

1. 依次获取中缀表达式的元素，
2. 若元素为操作数（数字/字母等），则加入后缀表达式中
3. 若元素为操作符，则压入栈中，此时对比入栈操作符与栈内元素的计算等级，等级大于或等于入栈元素的栈内操作符都将被弹出栈，加入到后缀表达式中
4. 左括号直接入栈，优先级最高，不弹出栈内元素
5. 右括号不入栈，而是弹出所有元素加入后缀表达式，直至遇见匹配的左括号，并弹出左括号但不加入后缀表达式中
6. 当中缀表达式的元素耗尽后，依次弹出栈内元素加入到后缀表达式中。

代码实现过程如下，

完整代码

 from linked_list_stack import Stack

 SIGN = {'+': 1, '-': 1, '*': 2, '/': 2, '(': 3}

 def infix_to_postfix(expr):
     global SIGN
     out = []
     s = Stack()
     for i in expr:
         if i in SIGN.keys():
             # Pop all high level sign except left bracket
             while s.top():
                 if SIGN[s.top()] < SIGN[i] or s.top() == '(':
                     break
                 out.append(s.pop())
             # Push sign
             s.push(i)
         elif i == ')':
             # Pop all sign until left bracket encountered
             while s.top() != '(':
                 out.append(s.pop())
             # Pop left bracket
             s.pop()
         else:
             # Push number
             out.append(i)

     while s.top():
         out.append(s.pop())
     return out

 if __name__ == '__main__':
     ep = 'a + b * c + ( d * e + f ) * g'
     print(' '.join(infix_to_postfix(ep.split(' '))))

分段解释

首先从链表栈中导入栈类，并定义各个操作符的优先级

 from linked_list_stack import Stack

 SIGN = {'+': 1, '-': 1, '*': 2, '/': 2, '(': 3}

接着定义转换函数，

1. 函数接受一个中缀表达式的可迭代对象，创建列表out存放后缀表达式，以及一个空栈s
2. 随后开始遍历中缀表达式，判断遍历元素的类型，若为操作数则加入out，
3. 若为右括号则依次弹出栈内元素加入out列表，直到遇见左括号，弹出左括号不加入out，
4. 若为普通操作符则压入栈中，并对比栈内操作符优先级，依次弹出高优先级或相同优先级的操作符，
5. 遍历结束后依次弹出栈内元素，最后返回后缀表达式的字符串形式。

 def infix_to_postfix(expr):
     global SIGN
     out = []
     s = Stack()
     for i in expr:
         if i in SIGN.keys():
             # Pop all high level sign except left bracket
             while s.top():
                 if SIGN[s.top()] < SIGN[i] or s.top() == '(':
                     break
                 out.append(s.pop())
             # Push sign
             s.push(i)
         elif i == ')':
             # Pop all sign until left bracket encountered
             while s.top() != '(':
                 out.append(s.pop())
             # Pop left bracket
             s.pop()
         else:
             # Push number
             out.append(i)

     while s.top():
         out.append(s.pop())
     return out

 if __name__ == '__main__':
     ep = 'a + b * c + ( d * e + f ) * g'
     print(' '.join(infix_to_postfix(ep.split(' '))))

最后可以得到表达式输出结果为

a b c * + d e * f + g * +

2 后缀表达式的计算

后缀表达式的计算过程其实也是后缀转换为中缀的一个过程：

1. 首先依次遍历后缀表达式，
2. 当元素为操作数时，压入栈中，
3. 当元素为操作符时，弹出栈内最顶上的两个元素，进行操作运算，将得到的结果再次压入栈中，
4. 直到后缀表达式遍历结束，此时栈内只有唯一的一个元素即最终的运算结果，弹出栈即可

实现的过程十分简单，具体代码如下，其中中缀表达式转后缀表达式的方法为前面定义的方法

完整代码

 from linked_list_stack import Stack  

 SIGN = {'+': 1, '-': 1, '*': 2, '/': 2, '(': 3}  

 def postfix_calc(expr):
     global SIGN
     s = Stack()
     for i in expr:
         if i in SIGN.keys():
             right = str(s.pop())
             left = str(s.pop())
             cal = ' '.join((left, i, right))
             # cal = ' '.join([str(s.pop()), i, str(s.pop())][::-1])
             s.push(eval(cal))
         else:
             s.push(i)
     return s.pop()  

 if __name__ == '__main__':
     ep = '( ( 2 + 3 ) * 8 + 5 + 3 ) * 6'
     print(eval(ep))
     print(postfix_calc(infix_to_postfix(ep.split(' '))))  

     ep = '3 + ( 2 * 9 ) / 2 * ( 3 + 6 ) * 7'
     print(eval(ep))
     print(postfix_calc(infix_to_postfix(ep.split(' '))))  

最后测试直接运算中缀表达式和中缀转后缀后再计算得到的结果，两者结果相同。

288
288
570.0
570.0