逆波兰表达式中缀转后缀

逆波兰表达式算法
中缀转后缀的核心思路：
中缀表达式a + b*c + (d * e + f) * g，其转换成后缀表达式则为a b c * + d e * f + g * +。

转换过程需要用到栈，具体过程如下：

1）如果遇到操作数，我们就直接将其输出。

2）如果遇到操作符，则我们将其放入到栈中，遇到左括号时我们也将其放入栈中。

3）如果遇到一个右括号，则将栈元素弹出，将弹出的操作符输出直到遇到左括号为止。注意，左括号只弹出并不输出。

4）如果遇到任何其他的操作符，如（“+”， “*”，“（”）等，从栈中弹出元素直到遇到发现更低优先级的元素(或者栈为空)为止。弹出完这些元素后，才将遇到的操作符压入到栈中。有一点需要注意，只有在遇到" ) “的情况下我们才弹出” ( “，其他情况我们都不会弹出” ( "。

5）如果我们读到了输入的末尾，则将栈中所有元素依次弹出。

mport java.util.Scanner;
import java.util.Stack;

public class niPoland {

    final int OPER = 1;
    final int NUM = 0;
    final int ERROR = -1;
    Stack<String> stack;
    String[] nums;
    public int judgeOper(String oper){
        int res;
        switch (oper){
            case "+":
            case "-":
            case "*":
            case "\\":
            case "(":
            case ")":
                res = OPER;
                break;
            case "0":case "1":case "2":case "3":case "4":case "5":case "6":case "7":case "8":case "9":
                res = NUM;
                break;
                default:
                    res =  ERROR;
                    break;

        }
        return res;
    }

    public int operLevel(String oper){
        int res = 0;
        switch (oper){
            case "+":
            case "-":
                res = 0;
                break;
            case "*":
            case "\\":
                res = 1;
                break;
            case "(":
            case ")":
                res = 2;
                break;
        }
        return res;
    }

    public boolean judgeOper(String oper1, String oper2){
        int oper1Level = operLevel(oper1);
        int oper2level = operLevel(oper2);
        if(oper1Level < oper2level){
            return false;
        }
        else return true;
    }

    //中缀转后缀
    public String middleToBack(String input){
        int i = 0;
        stack = new Stack<>();
        StringBuilder stringBuilder = new StringBuilder();
        while(true){
            if(i == input.length())break;
            String temp = String.valueOf(input.charAt(i));
            if(judgeOper(temp) == OPER){
                if(!(temp.equals(")"))) {
                    if(!(stack.isEmpty())) {
                        String oper = stack.peek();
                        while (judgeOper(oper, temp) && !(stack.peek().equals("("))) {
                            stringBuilder.append(stack.pop());
                            if(stack.isEmpty()) break;
                            else oper = stack.peek();
                        }
                    }
                    stack.push(temp);
                }
                else if(temp.equals(")")){
                    while(!(stack.peek().equals("("))){
                        stringBuilder.append(stack.pop());
                    }
                    stack.pop();
                }
            }
            else if(judgeOper(temp) == NUM){
                stringBuilder.append(temp);
            }
            else{
                System.out.println("ERROR");
            }
            i++;

        }
        while(!(stack.isEmpty())){
            stringBuilder.append(stack.pop());
        }
        return stringBuilder.toString();
    }

    public String getInput(){
        Scanner in = new Scanner(System.in);
        String res = in.nextLine().trim();
        return res;
    }

    public static void main(String[] args){
        niPoland test = new niPoland();
        String input = test.getInput();
        String res = test.middleToBack(input);
        System.out.print(res);
    }
}