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