算术表达式的前缀表达式，中缀表达式和后缀表达式

这里所谓的前缀，中缀，后缀是根据操作符的位置来定的，

如果操作符在操作数前面，则称为前缀表达式，例如“- + 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出栈顶的两个元素，进行计算后将结果又压入栈中，这样一直下去，直到得到最终结果。