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

一、为什么要用后缀表达式求值

将中缀表达式转换成等价的后缀表达式后，求值时，不需要再考虑运算符的优先级，只需从左到右扫描一遍后缀表达式即可

二、后缀表达式求值

后缀表达式也叫做逆波兰表达式，其求值过程可以用栈来辅助存储。假定待求值的表达式为

1 2 3 + 4 * + 5 -

它具有如下的几个步骤

（1）遍历表达式 遇到的数字首先放入栈中，此时栈如下所示

（2）接着读到了+ 号，则弹出了3和2 计算出结果等于5，并且将5压入了栈中

（3）读到数字4，直接压入栈中

（4）读取到* 号，栈中弹出4和5 计算出结果20然后在压入栈中

（5）读取到 + 号，栈中弹出20和1两个元素相加，将结果21压入栈中

（6）读取到数字5，直接压入栈中

（7）读取 - 号，从栈中弹出num1->5 num2->21,用num2-num1得到16压入栈中

（8） 此时，已经扫描到了最后的元素，栈中还剩下一个元素16 最后剩下的元素为后缀表达式的值

代码实现

    // rpnList为后缀表达式 list 
    // 比如 后缀表达式 1 2 3 + 4 * 5 - + 对应的 rpnList 为 [1,2,3,+,4,*,5,-,+] 
    private static int calculator(List<String> rpnList) {

        Stack<String> stack = new Stack<>();
        for (String item : rpnList) {
            // 正则取出数字
            if (item.matches("\\d+")) { // 匹配的是多位数
                stack.push(item);
            } else {
                // pop出两个数 并且运算 在入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res;
                if ("+".equals(item)) {
                    res = num1 + num2;
                } else if ("-".equals(item)) {
                    res = num1 - num2;
                } else if ("*".equals(item)) {
                    res = num1 * num2;
                } else if ("/".equals(item)) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符错误");
                }
                stack.push("" + res);
            }
        }
        return Integer.parseInt(stack.pop());
    }

三、中缀表达式转换后缀表达式

3.1 规则

• 1、初始化栈和集合：运算符号栈s1和存储空间集合s2
• 2、从左到右扫描中缀表达式
• 3、遇到操作数时，将其加入s2
• 4、遇到运算符时，比较其与s1栈顶运算符的优先级

• 4.1、如果s1为空，或栈顶运算符为左括号‘(’，则直接将此运算符入栈
• 4.2、否则，若优先级比栈顶运算符的高，也将运算符压入s1
• 4.3、否则，将s1栈顶的运算符弹出并加入到s2中，再次转到 流程4

• 5、遇到括号时：

• 5.1、如果是左括号‘(’，则直接压入s1
• 5.2、如果是右括号‘)’，则依次弹出s1栈顶的运算符，并且加入s2，直到遇到左括号为止，此时将这一对括号丢弃

• 6、重复步骤 2-5，直到表达式的最右边
• 7、将s1中剩余的运算符依次弹出并加入s2
• 8、s2结果即为中缀表达式对应的后缀表达式

3.2 实例

以上面的转换为实例，比如输入 1 + ( ( 2 + 3 ) * 4 ) - 5，那么怎么转换成后缀表达式呢？

扫描到的元素	s2集合中元素	s1(栈底->栈顶)	说明
1	1	空	数字 直接加入到集合中
+	1	+	s1为空，直接入栈
(	1	+(	左括号 直接入栈
(	1	+( (	同上
2	12	+( (	数字
+	12	+( (+	s1栈顶是左括号，运算符直接入栈
3	123	+( (+	数字
)	123+	+(	右括号，弹出运算符直至遇到左括号
*	123+	+( *	s1栈顶是左括号，运算符直接入栈
4	123+4	+( *	数字
)	123+4 *	+	右括号，弹出运算符直至遇到左括号
-	123+4 *+	-	-与+优先级相同，因此弹出+号，在压入-
5	123+4 *+ 5	-	数字
到达最右端	123+4 *+ 5 -	空	s1中剩余的运算符

至此整个过程转换完毕

即中缀表达式1 + ( ( 2 + 3 ) * 4 ) - 5 的后缀表达式为1 2 3 + 4 * + 5 -

3.2 实现代码

  // midList 为中缀表达式 list 
  // 比如 中缀表达式 1 + ( ( 2 + 3 ) * 4 ) - 5 对应的 midList为 [1,+,(,(,2,+,3,),*,4,),-,5]
 private static List<String> parseSuffixExpressionList(List<String> midList) {
        // 符号栈s1 以及存放空间结果栈s2
        Stack<String> s1 = new Stack<>();
        List<String> s2 = new ArrayList<>();

        // 遍历midList
        midList.forEach(item -> {
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if ("(".equals(item)) {
                s1.push(item);
            } else if (")".equals(item)) { // 右括号
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop(); // 将( 弹出s1 消除小括号
            } else {
                // item优先级小于等于s1栈顶元素，将s1栈顶的运算符弹出并且加入到s2中，再次与新的栈顶元素的优先级比较
                while (s1.size() != 0 && !"(".equals(s1.peek()) && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
        });
        // 将s1中剩余的运算符依次弹出并且加入s2
        while (s1.size() != 0) {
            s2.add(s1.pop());
        }
        return s2;
    }