实现中缀表达式转后缀表达式（java）

实现中缀表达式转后缀表达式

中缀表达式转后缀表达式的思路步骤分析：
1.初始化两个栈：运算符栈s1和存储中间结果的栈s2；
2.从左至右扫描中缀表达式；
3.如果遇到操作数时，将其压入s2；
4.如果运算符时，比较其与s1栈顶运算符的优先级；
 （1）如果s1为空，或栈顶运算符为左括号“（”，则直接入栈；
 （2）否则，若优先级比栈顶运算符高，也将运算符压入s1；
 （3）否则，将s1栈顶运算符弹出并压入s2中，再转到4-（1）与s1中新的栈顶运算符相比较；
5.遇到括号时：
 （1）如果是左括号“(”,则直接压入s1；
 （2）如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2,直到遇到左括号，此时将这一对括号丢弃；
6.重复步骤2至5，直到表达式的最右边；
7.将s1中剩余的运算符依次弹出并压入s2；
8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。
代码如下：只包含+,-,×，÷的运算规则

public class InfixToSuffix {
    public static void main(String[] args) {
        String infixExpretion = "1+((2+3)*4)-5";
        List<String> strings = toInfixExpression(infixExpretion);
        List<String> list = parseSuffixExpressionList(strings);
        System.out.println(list);
    }

    public static List<String> toInfixExpression(String infixExpression){
        List<String> ls = new ArrayList<>();
        char c;
        String str;
        int i=0;
        do{
            if ((c=infixExpression.charAt(i)) <= 48 || (c=infixExpression.charAt(i)) >= 57){
                ls.add("" + c);
                i++;
            }else{
                str = "";
                    while (i<infixExpression.length() && (c=infixExpression.charAt(i)) >= 48 && (c=infixExpression.charAt(i)) <= 57){
                        str += c;
                        i++;
                    }
                    ls.add(str);
            }
        }while (i<infixExpression.length());
        return ls;
    }

    public static List<String> parseSuffixExpressionList(List<String> list){
        Stack<String> operStack = new Stack<>();
        List<String> resList = new ArrayList<>();
         for (String item : list){
             if (item.matches("\\d+")){
                 resList.add(item);
             }else if (item.equals("(")){
                 operStack.push(item);
             //如果是右括号“）”，则依次弹出s1栈顶的运算符，并压入s2,直到遇到左括号，此时将这一对括号丢弃；
             }else if (item.equals(")")){
                 while (!operStack.peek().equals("(")){
                     resList.add(operStack.pop());
                 }
                 operStack.pop();
             }else{
                 while (operStack.size()!=0 && Operation.getValue(operStack.peek()) >= Operation.getValue(item)){
                     resList.add(operStack.pop());
                 }
                 operStack.push(item);
             }
         }
         while (operStack.size()!=0){
             resList.add(operStack.pop());
         }
         return resList;
    }
}

class Operation{
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 1;
    private static int DIV = 1;
    private static int LEFT = 0;

    public static int getValue(String oper){
        int res = 0;
        switch (oper){
            case "+":
                res = ADD;
                break;
            case "-":
                res = SUB;
                break;
            case "*":
                res = MUL;
                break;
            case "/":
                res = DIV;
                break;
            case "(":
                res = LEFT;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }
        return res;
    }
}

结果如下：