10、栈-中缀表达式转后缀表达式

来源：https://www.bilibili.com/video/BV1B4411H76f?p=39

一、思路

1、初始化同样设置两个栈，符号栈s1和结果栈s2；

2、从左到右扫描中缀表达式；

3、遇到数据，直接入栈s2；

4、遇到符号：

　　4.1、如果s1为空，或者s1的栈顶符号为 "(" ，也就是左括号，直接入栈s1

　　4.2、如果当前符号比s1栈顶的符号优先级高，直接入栈s1

　　4.3、否则，将s1栈顶的那个运算符弹出，压入到s2，然后回到4.1继续比较，直到入栈。

5、遇到括号：

　　5.1、左括号"("直接入栈s1

　　5.2、右括号")"，将s1中的运算符依次弹出，入栈s2，直到遇到左括号"("，此时将括号删除

6、重复步骤2-5,直到表达式结束

7、将s1中剩余的符号弹出，入栈s2

8、s2中的内容依次弹出，逆序，则为后缀表达式

二、实现

1、根据原始字符串的到中缀表达式对应的数组，要注意多位数的存在

    //根据原始字符串得到中缀表达式的字符串
    public static List<String> getInfixArray(String s){
        List<String> list = new ArrayList<>();
        int i = 0;//遍历原始的表达式
        char c;//获取当前位置的字符
        String keepNum;//如果是多位数可以用来拼接
        while (true){
            if((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57){
                //不是数字
                list.add(""+c);
                i++;
            }else {
                keepNum = "";
                while (i < s.length() && (c = s.charAt(i))>= 48 && (c = s.charAt(i)) <= 57 ){
                    keepNum += c;
                    i++;
                }
                list.add(""+keepNum);
            }
            if(i > s.length() - 1){
                break;
            }
        }
        return list;
    }

测试

        //原始表达式
        String expression = "1+((2+3)*4)-5";
        //根据原始表达式得到中缀表达式
        List<String> infixArray = getInfixArray(expression);
        System.out.println(infixArray);

结果

[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]

2、按照思路将中缀表达式转化为后缀表达式（这里为了方便，将结果栈s2定义为数组，不必进行弹出后再倒序）。同时，定义了一个判断符号优先级的方法。

    public static List<String> infixToSuffix(List<String> infix){
        //符号栈
        Stack<String> s1 = new Stack<String>();
        //结果，由于后期需要逆序得到结果，这里用数组
        List<String> s2 = new ArrayList<>();

        for (String item : infix) {
            if(item.matches("\d+")){
                //如果是一个数字
                s2.add(item);
            }else if(item.equals("(")){
                //左括号，入符号栈
                s1.push(item);
            }else if(item.equals(")")){
                //右括号,直到找到左括号
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();//弹出左括号
            }else {
                //不为空，且优先级小于等于栈顶的
                while (s1.size() != 0 && properties(item) <= properties(s1.peek())){
                    s2.add(s1.pop());
                }
                //否则，直接入栈
                s1.push(item);
            }
        }

        //表达式遍历完成，s1出栈加入到s2
        while (!s1.isEmpty()){
            s2.add(s1.pop());
        }
        return s2;
    }

    //计算符号的优先级
    public static int properties(String oper){
        int res = 0;
        switch (oper){
            case "+":
                res = 1;
                break;
            case "-":
                res = 1;
                break;
            case "*":
                res = 2;
                break;
            case "/":
                res = 2;
                break;
            default:
                System.out.println("运算符错误");
                break;
        }
        return res;
    }

测试

        //中缀转后缀
        List<String> suffix = infixToSuffix(infixArray);
        System.out.println(suffix);
        System.out.println();

        int res = calculate(suffix);
        System.out.println(res);

结果

运算符错误
运算符错误
[1, 2, 3, +, 4, *, +, 5, -]

16