题解 | #四则运算#

import java.util.*;

//中缀转后缀再计算
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String expression = sc.nextLine();
        System.out.println(eval(expression));
    }

    public static int eval(String expression){
        expression = expression.replace('[','(');
        expression = expression.replace(']',')');
        expression = expression.replace('{','(');
        expression = expression.replace('}',')');
        List<String> expressionList = parseToExpression(expression);
        List<String> postfixExpression = castToPostfixExpression(expressionList);
        return eval(postfixExpression);
    }
    public static int eval(List<String> postfixExpression){
        Stack<String> stack = new Stack<>();
        Set<String> sign = new HashSet<>();
        sign.add("+");
        sign.add("-");
        sign.add("*");
        sign.add("/");

        for (int i = 0; i < postfixExpression.size(); i++) {
            String s = postfixExpression.get(i);
            if(sign.contains(s)){
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                switch (s){
                    case "+":
                        stack.push(String.valueOf(num1+num2));
                        break;
                    case "-":
                        stack.push(String.valueOf(num1-num2));
                        break;
                    case "*":
                        stack.push(String.valueOf(num1*num2));
                        break;
                    case "/":
                        stack.push(String.valueOf(num1/num2));
                        break;
                }
            }else {
                stack.push(s);
            }
        }
        return Integer.parseInt(stack.lastElement());
    }

    public static List<String> castToPostfixExpression(List<String> infixExpression){
        Map<String,Integer> isp = new HashMap<>();
        Map<String,Integer> icp = new HashMap<>();
        initIspAndIcp(isp,icp);
        Stack<String> stack = new Stack<>();
        List<String> result = new ArrayList<>();
        stack.push("#");
        infixExpression.add("#");
        for (int i = 0; i < infixExpression.size(); i++) {
            String s = infixExpression.get(i);
            if(icp.containsKey(s)){
                while (icp.get(s)<=isp.get(stack.lastElement())){
                    if(icp.get(s)<isp.get(stack.lastElement())){
                        result.add(stack.pop());
                    }
                    if(icp.get(s) == isp.get(stack.lastElement())){
                        stack.pop();
                        break;
                    }
                }
                if(!s.equals(")")){
                    stack.push(s);
                }

            }else {
                result.add(s);
            }
        }
        return result;
    }

    public static List<String> parseToExpression(String expression){
        char[] chs = expression.toCharArray();
        List<String> stringList = new ArrayList<>();
        List<Character> numbers = new ArrayList<>();
        boolean digitFlag = false;

        for (int i = 0; i < chs.length; i++) {
            char temp = chs[i];

            if(Character.isDigit(temp)){
                if(!digitFlag){
                    digitFlag = true;
                }
                numbers.add(temp);
                if(i == chs.length-1){
                    digitFlag = false;
                    StringBuilder sb = new StringBuilder();
                    for (int j = 0; j < numbers.size(); j++) {
                        sb.append(numbers.get(j));
                    }
                    stringList.add(sb.toString());
                    numbers.clear();
                }
            }else{
                if(digitFlag){
                    digitFlag = false;
                    StringBuilder sb = new StringBuilder();
                    for (int j = 0; j < numbers.size(); j++) {
                        sb.append(numbers.get(j));
                    }
                    stringList.add(sb.toString());
                    numbers.clear();
                    stringList.add(String.valueOf(temp));
                    continue;
                }
                if(temp == '-'){
                    if((i-1>=0&&chs[i-1] == '(')||i == 0){
                        digitFlag = true;
                        numbers.add(temp);
                        continue ;
                    }
                }
                stringList.add(String.valueOf(temp));
            }
        }
        return stringList;
    }

    public static void initIspAndIcp(Map<String,Integer> isp,Map<String,Integer> icp){
        isp.put("#",0);
        isp.put("(",1);
        isp.put("+",3);
        isp.put("-",3);
        isp.put("*",5);
        isp.put("/",5);
        isp.put(")",6);

        icp.put("#",0);
        icp.put("(",6);
        icp.put("+",2);
        icp.put("-",2);
        icp.put("*",4);
        icp.put("/",4);
        icp.put(")",1);
    }
}