蓝桥杯 算法训练 表达式计算（中缀表达式）

资源限制
时间限制：1.0s   内存限制：256.0MB
问题描述
　　输入一个只包含加减乖除和括号的合法表达式，求表达式的值。其中除表示整除。
输入格式
　　输入一行，包含一个表达式。
输出格式
　　输出这个表达式的值。
样例输入
1-2+3*(4-5)
样例输出
-4
数据规模和约定
　　表达式长度不超过100，表达式运算合法且运算过程都在int内进行。

本题就是简单的利用栈计算中缀表达式，可以先转为后缀表达式（逆波兰表达式），也可以直接计算，这里是直接计算.

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

/**
 * @author Meng
 * @date 2020/3/6
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String str=scanner.next();
        Stack<Integer> numbers=new Stack<>();            //数字栈
        Stack<Character> operator=new Stack<>();         //操作符栈
        char[] arr=str.toCharArray();
        for (int i = 0; i < arr.length; i++) {
            char c=arr[i];
            if(isOperator(c)){
                if(c=='('){                               //左括号直接入操作符栈
                    operator.push(c);
                }else if(c==')'){                         //右括号则弹出所有符号计算直到出现左括号
                    char x=operator.lastElement();
                    while (x!='('){
                        operator.pop();
                        Integer first=numbers.pop();
                        Integer second=numbers.pop();
                        numbers.push(computer(first,second,x));      //计算出来的结果入栈
                        x=operator.lastElement();
                    }
                    operator.pop();                                
                }else{                                   //其余操作符则弹出所有优先级大于等于该操作符直到出现一个小于的，并计算
                    if(!operator.isEmpty()) {            
                        char x = operator.lastElement();
                        while (x != '(' && compare(x, c)) {
                            operator.pop();
                            Integer first = numbers.pop();
                            Integer second = numbers.pop();
                            numbers.push(computer(first, second,  x));  //计算出来的结果入栈
                            if(operator.isEmpty())break;
                            x = operator.lastElement();
                        }
                    }
                    operator.push(c);             //该操作符入栈
                }
            }else{                               //数字直接入栈
                String num="";
                while (i<arr.length&&!isOperator(arr[i])){
                    c=arr[i];
                    num+=c;
                    i++;
                }
                i--;
                numbers.push(Integer.valueOf(num));
            }
        }
        while (!operator.isEmpty()){                 //操作后对操作栈剩余的操作符全部依次计算求出结果
            char x=operator.pop();
            Integer first=numbers.pop();
            Integer second=numbers.pop();
            numbers.push(computer(first,second,x));
        }
        System.out.println(numbers.pop());
    }

    /**
     * 相应计算
     * @param first
     * @param second
     * @param operator
     * @return
     */
    private static Integer  computer(Integer first,Integer second,char operator){
        switch (operator){
            case '+': return second+first;
            case '-': return second-first;
            case '*': return second*first;
            case '/': return second/first;
        }
        return 0;
    }

    /**
     *
     * @param first
     * @param second
     * @return  返回first是否大于等于second
     */
    private static boolean compare(char first,char second){
        if(first=='*'||first=='/')return true;
        else{
            if(second=='+') return true;
            if(second=='-') return true;
        }
        return false;
    }

    /**
     * 判断是否是操作符
     * @param c
     * @return
     */
    private static boolean isOperator(char c){
        return c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')';
    }
}

评测状况

如果有疑问的可以直接问我，或者有错误也可以指出.