表达式求值

描述

给定一个字符串描述的算术表达式，计算出结果值。

输入字符串长度不超过 100 ，合法的字符包括 ”+, -, *, /, (, )” ， ”0-9” 。

数据范围：运算过程中和最终结果均满足 ∣���∣≤231−1 ∣val∣≤231−1  ，即只进行整型运算，确保输入的表达式合法

输入描述：

输入算术表达式

输出描述：

计算出结果值

示例1

输入：

400+5

输出：

405

答案：

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String a = in.nextLine();
            System.out.println(getVal(a));
        }

    }


    public static int getVal(String s) {
        Stack<Character> stack = new Stack<>();
        Stack<Integer> dataStack = new Stack<>();
        List<Object> list = new ArrayList<>();
        char[] array = s.toCharArray();
        StringBuilder item = new StringBuilder();

        for (int i=0; i<array.length; i++) {
            char tmp = array[i];
            if (tmp == '+' || tmp == '-' || tmp == '*' || tmp == '/' || tmp == '(' ||
                    tmp == ')') {
                // 针对首个“-”或者括号中的“-”，-1*(-1-1)
                if ((i==0 && array[i] =='-') || (array[i]=='-' && array[i-1]=='(')) {
                    item.append('-');
                    continue;
                }
                if (item.length() > 0) {
                    int val = Integer.valueOf(item.toString());
                    dataStack.push(val);
                    item.delete(0, item.length());
                }

                if (tmp == '(') {
                    stack.push(tmp);
                } else if (tmp == '+' || tmp == '-' || tmp == '*' || tmp == '/') {
                    if (tmp == '*' || tmp == '/') {
                        dealKuohao(stack, dataStack, '(', true);
                        stack.push(tmp);
                    } else if (tmp == '+' || tmp == '-') {
                        dealKuohao(stack, dataStack, '(', false);
                        stack.push(tmp);
                    } 
                } else if (tmp == ')') {
                    dealKuohao(stack, dataStack, ')', true);
                }
            } else {
                item.append(tmp);
            }
        }

        if (item.length() > 0) {
            dataStack.push(Integer.valueOf(item.toString()));
        }

        lastDeal(stack, dataStack);
        return dataStack.pop();
    }

    /**
        opStack:操作栈
        dataStack:数据栈
        isKuohao:是否带括号
        kuohao:括号（'()'或')'）
        isChChu:是否乘除
     */
    public static boolean dealKuohao(Stack<Character> opStack, Stack<Integer> dataStack, char kuohao, boolean isChChu) {
        if (kuohao == '(') { // 中间处理，还未遇到右括号
            while (!opStack.isEmpty()) {
                char op = opStack.pop();
                if (dataStack.size() < 2 || op == '(') {
                    opStack.push(op);
                    break;
                }
                if (isChChu && (op=='+' || op=='-')) {
                    opStack.push(op);
                    break;
                }
                int a1 = dataStack.pop();
                int a2 = dataStack.pop();
                switch (op) {
                    case '+':
                        dataStack.push(a1 + a2);
                        break;
                    case '-':
                        dataStack.push(a2 - a1);
                        break;
                    case '*':
                        dataStack.push(a1 * a2);
                        break;
                    case '/':
                        dataStack.push(a2 / a1);
                        break;
                }
            }
        }
        else { // 整个括号内部处理
            while (!opStack.isEmpty()) { 
                char op = opStack.pop();
                if (dataStack.size() < 2) {
                    break;
                }
                if (op != '(') {
                    int a1 = dataStack.pop();
                    int a2 = dataStack.pop();
                    switch (op) {
                        case '+':
                            dataStack.push(a1 + a2);
                            break;
                        case '-':
                            dataStack.push(a2 - a1);
                            break;
                        case '*':
                            dataStack.push(a1 * a2);
                            break;
                        case '/':
                            dataStack.push(a2 / a1);
                            break;
                    }
                }
                else {
                    break;
                }
            }
        }
        return true;
    }

    /**
        最后处理
        opStack:操作栈
        dataStack:数据栈
        isKuohao:是否带括号
     */
    public static boolean lastDeal(Stack<Character> opStack, Stack<Integer> dataStack) {
        while (!opStack.isEmpty()) {
            char op = opStack.pop();
            int a1 = dataStack.pop();
            int a2 = dataStack.pop();
            switch (op) {
                case '+':
                    dataStack.push(a1 + a2);
                    break;
                case '-':
                    dataStack.push(a2 - a1);
                    break;
                case '*':
                    dataStack.push(a1 * a2);
                    break;
                case '/':
                    dataStack.push(a2 / a1);
                    break;
            }
        }
        return true;
    }
}