LeetCode之计算器

这个思想能够解决含有+ - * /（）的表达式

步骤：

一、对表达式进行预处理，把式子中的空格去掉，把（-10）替换为（0-10）;

如：String s = "1 + 10 + 5 * (-10 + 5)"

对s进行预处理

s = s.replaceAll(" ","");
s = s.replaceAll("\\(-", "(0-",);
char[] chars = s.toCharArray(); 

得到结果 s = "1+10+5*(0-10+5)"

二、使用两个栈 stNums 和 stOps分别存放数字和操作符：

由于第一个数可能是负数，为了减少边界判断。一个小技巧是先往 stNums 添加一个 0

// 创建一个栈来存放所有的数字
Deque<Integer> stNums = new LinkedList<>();

// 为了防止第一个数为负数，先往 nums 加个 0
stNums.addLast(0);

// 创建一个栈存放所有运算符
Deque<Character> stOps = new LinkedList<>();

注意：为什么我们用双端队列来Deque来模拟栈呢？

因为Java堆栈Stack类已经过时，Java官方推荐使用Deque替代Stack使用。可以通过Deque的addLast()/offerLast(), removaLast()/pollLast(), getLast()/peekLast() 来达到栈后进先出的效果

三、然后从前往后进行遍历，：

• 当chars[i] >= '0' && chars[i] <= '9' : 从当前位置开始继续往后取，用num来记录，最后放入stNums

if(chars[i] >= '0' && chars[i] <= '9'){
    int num = ch - '0'; //num存储当前数字 比如出现123的情况
    while(i + 1 < len && chars[i + 1] >= '0' && chars[i + 1] <= '9'){
        num = num * 10 + (chars[i + 1] - '0');
        i++;
    }
    stNums.offerLast(num)
}

• 当chars[i] == ‘+’ || ‘-’ || ‘*’ || ‘/’ || ‘^’ || ‘%’ : 需要将操作放入stOps 中。在放入之前，需要比较该运算符和stOps栈内的运算符，当「栈内运算符」比「当前运算符」优先级高/同等的时候，对放入栈类的数先进行计算直到stOps中遇见「栈内运算符」比「当前运算符」优先级低时候或者遇到左括号结束，并把当前操作符放入stOps中
• 当chars[i] == '('  : 直接加入 ops 中，等待与之匹配的 ')'
• 当chars[i] == ')'  : 使用现有的 stNums 和 stOps 进行计算，直到遇到左边最近的一个左括号为止，计算结果放到 stNums中

例子 只有「栈内运算符」比「当前运算符」优先级高/同等，才进行运算 是什么意思：

因为我们是从前往后做的，假设我们当前已经扫描到 2 + 1 了（此时stNums中为： 2 1， stOps为 +）。

如果后面出现的 + 2 或者 - 1 的话，满足「栈内运算符」比「当前运算符」优先级高/同等，可以将 2 + 1 算掉，把结果放到 nums 中（此时stNums中为： 3， stOps为 ）；
如果后面出现的是 * 2 或者 / 1 的话，不满足「栈内运算符」比「当前运算符」优先级高/同等，这时候不能计算 2 + 1，则把* 2放入栈中（此时stNums中为： 2 1 2， stOps为 + *）。

    // 使用 map 维护一个运算符优先级
    // 这里的优先级划分按照「数学」进行划分即可，数字越高优先级越高
    Map<Character, Integer> map = new HashMap<>(){{
        put('-', 1);
        put('+', 1);
        put('*', 2);
        put('/', 2);
        put('%', 2);
        put('^', 3);
    }};
    static int calculate(String s) {
        // 将所有的空格去掉
        s = s.replaceAll(" ", "");
        //将 (- 替换为 (0-
        s = s.replaceAll("\\(-", "(0-");
        char[] chars = s.toCharArray();
        int len = s.length();
        // 创建一个栈来存放所有的数字
        Deque<Integer> stNums = new LinkedList<Integer>();
        // 为了防止第一个数为负数，先往 nums 加个 0
        stNums.offerLast(0);
        // 创建一个栈存放所有运算符
        Deque<Character> stOps = new LinkedList<Character>();
        for (int i = 0; i < len; i++) {
            char ch = chars[i];
            if(ch >= '0' && ch <= '9'){
                int num = ch - '0'; //num存储当前数字 比如出现123的情况
                while(i + 1 < len && chars[i + 1] >= '0' && chars[i + 1] <= '9'){
                    num = num * 10 + (chars[i + 1] - '0');
                    i++;
                }
                stNums.offerLast(num);
            }
            else if (ch == '(') {
                stOps.offerLast(ch);
            }
            else if (ch == ')') {
                // 计算到最近一个左括号为止
                while (!stOps.isEmpty()) {
                    if (stOps.peekLast() != '(') {
                        calc(stNums, stOps);
                    } else {
                        stOps.pollLast();
                        break;
                    }
                }
            }
            else {
                // 有一个新操作要入栈时，先把栈内可以算的都算了
                // 只有满足「栈内运算符」比「当前运算符」优先级高/同等，才进行运算,直到运算完毕
                while (!stOps.isEmpty() && stOps.peekLast() != '(') {
                    char prev = stOps.peekLast(); //检查stOps尾部运算符与当前运算符优先级谁高
                    if (map.get(prev) >= map.get(ch)) {
                        calc(stNums, stOps);
                    } else {
                        break;
                    }
                }
                stOps.offerLast(ch);
            }
        }
        // 将剩余的计算完
        while (!stOps.isEmpty()) calc(stNums, stOps);
        return stNums.peekLast();
    }

    static void calc(Deque<Integer> stNums, Deque<Character> stOps) {
        if (stNums.isEmpty() || stNums.size() < 2) return; //当stNums为空或者只存一个数的时候没法运算直接返回
        if (stOps.isEmpty()) return; //当stOps为空时候没法运算直接返回
        int num2 = stNums.pollLast(), num1 = stNums.pollLast();
        char op = stOps.pollLast();
        int res = 0;
        if (op == '+') {
            res = num1 + num2;
        } else if (op == '-') {
            res = num1 - num2;
        } else if (op == '*') {
            res = num1 * num2;
        } else if (op == '/') {
            res = num1 / num2;
        } else if (op == '^') {
            res = (int)Math.pow(num1, num2);
        } else if (op == '%') {
            res = num1 % num2;
        }
        //把计算结果重现放入栈中
        stNums.offerLast(res);
    }