10.中缀转后缀表达式

1.分析

2.代码

package com.atguigu.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {

        // 1+((2+3)*4)-5 => 123+4*+5-
        String expression = "1+((2+3)*4)-5";
        // 2.直接对str进行操作不方便，因此，先将""转为中缀表达式对应的List
        //   即“” =》ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println(infixExpressionList);
        // 3.将得到的中缀表达式对应的list转为后缀表达式对应的list
        // ArrayList[1,+,(,(,2,+,3,),*,4,),-,5] => 123+4*+5-
        List<String> sufffixExpressionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println(sufffixExpressionList);

    }

    // 将中缀表达式转为对应的list
    public static List<String> toInfixExpressionList(String s){
        // 先定义一个List，存放中缀表达式对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0;// 这是一个指针，用于遍历中缀表达式字符串
        String str; // 对多位数进行拼接
        char c;// 接收遍历的字符
        do {
            // 如果c是一个非数字，就需要加入到ls中
            if (((c=s.charAt(i)) < 48) || ((c=s.charAt(i)) > 57)){ // 非数字
                ls.add(""+c);
                i++;
            }else { // 数字
                str = "";// 先置空
                while ((i < s.length()) && ((c=s.charAt(i)) >= 48) && ((c=s.charAt(i)) <= 57)){
                    str+=c;
                    i++;
                }
                ls.add(str);
            }
        }while (i<s.length());
        return ls;
    }

    public static List<String> parseSuffixExpressionList(List<String> ls){
        // 定义运算符栈，结果栈（直接使用list)
        Stack<String> s1 = new Stack<String>(); // 运算符栈
        List<String> s2 = new ArrayList<String>(); // 结果栈（直接使用list)

        // 遍历 ls
        for (String item:ls){
            // 如果是一个数，进入s2
            if (item.matches("\\d+")){
                s2.add(item);
            }else if (item.equals("(")){
                s1.push(item);
            }else if (item.equals(")")){
                // 如果右括号,依次弹出s1栈顶运算符，并压入s2,直到遇到左括号为止，并将左括号丢弃
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();//左括号丢弃
            }else {
                // 当item的优先级小于等于s1栈顶运算符的优先级，将s1栈顶的运算符弹出并加入s2中
                while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)){
                    s2.add(s1.pop());
                }
                // 还需要将 item 压入s1
                s1.push(item);
            }
        }
        // s1中剩余运算符加入s2
        while (s1.size() != 0){
            s2.add(s1.pop());
        }
        return s2;
    }
}

// 编写一个类，Operation,可以返回一个运算符对应的优先级
class Operation{
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 1;

    // 返回对应的优先级
    public static int getValue(String operation){
        int result = 0;
        switch (operation){
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("运算符错误");
                break;
        }
        return result;
    }

}