题解 | #四则运算#

• 读入，Scanner.readLine()
• 中缀转后缀表达式，如图
• 
  
• 计算后缀表达式，如图

import java.util.*;

public class Main{
   private static List<String> transfer(String str){
        char[] chars = str.toCharArray();
        Stack<Character> stack = new Stack<>();
        //
        Map<Character,Integer> map = new HashMap<>();
        map.put('+',0);
        map.put('-',0);
        map.put('*',1);
        map.put('/',1);

        List<String> postList = new ArrayList<>();
        StringBuilder builder = new StringBuilder();
        if (chars[0]=='-'){
            //负号出现的第一种位置,
            builder.append('0');
        }

        for (int i = 0; i< chars.length; i++) {
            char aChar = chars[i];
            if (aChar == '-' && (chars[i-1] == '(' || chars[i-1]  == '[' || chars[i-1] == '{' )){
                postList.add("0");//负数第二种情况
            }
            if (aChar >= '0' && aChar<= '9'){
                //如果这是个位数，不是一个完整的数字时候应该怎么办？
                int t = i;
                StringBuilder numS = new StringBuilder();//数字处理
                numS.append(aChar);
                while (true){
                    //
                    ++t;
                    if (t<chars.length && chars[t] >= '0' && chars[t] <= '9'   ){
                        //下一位也是数字的一部分
                        numS.append(chars[t]);
                        i = t;//更新
                    }else {
                        break;
                    }
                }
                postList.add(numS.toString());
            }
            else if (aChar == '(' || aChar == '[' || aChar == '{' ){
                stack.push(aChar);
            }
            else if (aChar == ')' || aChar == ']' || aChar == '}' ){
                char left = (aChar == ')'?'(':(aChar == '}'?'{':(aChar == ']'?'[':' ')));
                while (!stack.isEmpty()){
                    char pop = stack.pop();
                    if (pop == left){//匹配到左括号
                        break;
                    }else {
                        postList.add(pop+"");
                    }
                }
            }else {//运算符号
                while (!stack.isEmpty()){
                    Character peek = stack.pop();
                    if (peek == '(' || peek == '[' || peek == '{'){
                        stack.push(peek);//括号表达式，左边没有运算符号
                        break;
                    }
                    else{
                        if (map.get(peek) >= map.get(aChar )){//栈顶有优先操作符号
                            postList.add(peek+"");
                        }else {
                            stack.push(peek);
                            break;//直到优先级低的元素被压入
                        }
                    }
                }
                stack.push(aChar);
            }
        }
        //栈元素写入后缀表达式
        while (!stack.isEmpty()){
            postList.add(stack.pop()+"");
        }
        return postList;
    }
    private static int calculate(List<String> str){
        Stack<Integer> stack = new Stack<>();
        for (String aChar : str) {
            if(aChar.equals("+") || aChar.equals( "-") || aChar.equals( "*") || aChar.equals( "/" ) ) {
                int a = stack.pop();
                int b = stack.pop();
                int c = 0;
                if (aChar.equals("+")){
                    c = b+a;
                }
                if (aChar.equals( "-")){
                    c = b-a;
                }
                if (aChar.equals( "*") ){
                    c = b*a;
                }
                if (aChar.equals( "/" )){
                    c = b/a;//后进先出
                }
                stack.push(c);
            }//运算符号//操作数
            else {
                stack.push(Integer.parseInt(aChar));
            }
        }
        return stack.pop();
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        System.out.println(calculate(transfer(str)));
    }
//main
}