2021-09-03

System.out.println("start");
        Scanner scanner = new Scanner(System.in);  //1+((2+3)*4)-5  9+(6+5)*2-7  400+5
        String str = scanner.next();
        String num = "";    //用于追加concat数字
        Stack<String> stackNum = new Stack<>();
        Stack<String> stackOpt = new Stack<>();

        //将输入的 中缀表达式 转换成 后缀表达式
        for (int i = 0; i < str.length(); i++) {
            if (str.substring(i,i+1).matches("[+-/*()]")) {     //正则表达式匹配操作符+-*/等
                if (num != "") {
                    stackNum.push(num);
                    num = "";
                }
                //若是存放操作符的栈为空或者栈顶为左括号（，则直接入栈
                if (stackOpt.isEmpty() || stackOpt.peek().equals("(") || str.substring(i,i+1).equals("(")) {
                    stackOpt.push(str.substring(i,i+1));
                }
                else if (!str.substring(i,i+1).equals(")")) {   //若是搜索到的下一个字符不是右括号则继续判断加减乘除
                        if (str.substring(i,i+1).equals("*")) {
                            while (!stackOpt.isEmpty()) {
                                if (!stackOpt.peek().equals("(") && stackOpt.peek().equals("/")) {
                                    stackNum.push(stackOpt.pop());  //乘除的优先级比较高，则除了栈顶为乘或者除要出栈，压入存放数据的栈中。否则直接压栈
                                } else if (!stackOpt.peek().equals("(") && stackOpt.peek().equals("*")) {
                                    stackNum.push(stackOpt.pop());
                                } else {
                                    break;
                                }
                            }
                            stackOpt.push(str.substring(i,i+1));

                        } else if (str.substring(i,i+1).equals("/")) {
                            while (!stackOpt.isEmpty()) {
                                if (!stackOpt.peek().equals("(") && stackOpt.peek().equals("*")) {
                                    stackNum.push(stackOpt.pop());  //同理乘法符号
                                } else if (!stackOpt.peek().equals("(") && stackOpt.peek().equals("/")) {
                                    stackNum.push(stackOpt.pop());
                                } else {
                                    break;
                                }
                            }
                            stackOpt.push(str.substring(i,i+1));

                        } else if (str.substring(i,i+1).equals("+")) {
                            while (!stackOpt.isEmpty()) {
                                if (!stackOpt.peek().equals("(")) {
                                    stackNum.push(stackOpt.pop());
                                } else {
                                    break;
                                }
                            }
                            stackOpt.push(str.substring(i,i+1));

                        } else if (str.substring(i,i+1).equals("-")) {
                            while (!stackOpt.isEmpty()) {
                                if (!stackOpt.peek().equals("(")) {
                                    stackNum.push(stackOpt.pop());
                                } else {
                                    break;
                                }
                            }
                            stackOpt.push(str.substring(i,i+1));
                        }
                } else {    //若是搜索到下一个字符为右括号），则从将栈中的操作符全部出栈，压进存放数据的栈中，直至栈顶为与之匹配的左括号，并且把这一对括号丢弃
                    while (!stackOpt.peek().equals("(")) {
                        stackNum.push(stackOpt.pop());
                    }
                    stackOpt.pop();
                }
            } else {    //是数字的数据就压入stackNum栈中，不过首先要将数字concat到num字符串，直到搜索到的下一个字符不是数字数据，再将num压入存放数字的栈中
                num = num.concat(str.substring(i,i+1));
                if (i == str.length()-1) {
                    stackNum.push(num);
                }
            }
        }

        while (!stackOpt.isEmpty()) {
            stackNum.push(stackOpt.pop());  //最后将存放操作符的栈剩余的全部压入存放数字的栈里
        }

        Stack<String> stack = new Stack<>();
        while (!stackNum.isEmpty()) {
            stack.push(stackNum.pop());     //调转stackNum的顺序，则是最终的后缀表达式
        }

        Stack<Integer> result = new Stack<>();
        int first = 0;
        int second = 0;
        int calculate = 0;
        while (!stack.isEmpty()) {  //注意减法的大小问题，还要除法的大小问题
            if (!stack.peek().matches("[+-/*]")) {
                result.push(Integer.parseInt(stack.pop()));
            } else if (stack.peek().equals("+")) {
                stack.pop();
                first = result.pop();
                second = result.pop();
                calculate = first + second;
                result.push(calculate);
            } else if (stack.peek().equals("-")) {
                stack.pop();
                first = result.pop();
                second = result.pop();
                calculate = second - first;
                result.push(calculate);
            } else if (stack.peek().equals("*")) {
                stack.pop();
                first = result.pop();
                second = result.pop();
                calculate = first * second;
                result.push(calculate);
            } else if (stack.peek().equals("/")) {
                stack.pop();
                first = result.pop();
                second = result.pop();
                calculate = second / first;
                result.push(calculate);
            }
        }
        System.out.println(result.pop());