力扣224(java)-基本计算器（困难）

题目：

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

注意:不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。

 示例 1：

输入：s = "1 + 1"
输出：2
示例 2：

输入：s = " 2-1 + 2 "
输出：3
示例 3：

输入：s = "(1+(4+5+2)-3)+(6+8)"
输出：23
 

提示：

• 1 <= s.length <= 3 * 105
• s 由数字、'+'、'-'、'('、')'、和 ' ' 组成
• s 表示一个有效的表达式
• '+' 不能用作一元运算(例如， "+1" 和 "+(2 + 3)" 无效)
• '-' 可以用作一元运算(即 "-1" 和 "-(2 + 3)" 是有效的)
• 输入中不存在两个连续的操作符
• 每个数字和运行的计算将适合于一个有符号的 32位 整数

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/basic-calculator
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

这道题对于现在的我还挺困难的参考三叶姐@宫水三叶的题解，梳理一下这道题的思路

利用双栈来解决：

• 使用栈nums:来存放所有的操作数
• 使用栈ops：来存放所有的操作符

将s中所有的空格去掉，并转换成字符数组，然后从前往后遍历字符，根据遇到的字符来分情况讨论:

• 遇到左括号 ( :就将其加入到ops中，等待与之匹配的右括号 );
• 遇到右括号  )：ops中操作符不为空时，就将栈中已有操作数和操作符进行计算，将计算结果放进nums中，直到遇到与之匹配的最近的左括号停止，弹出左括号；
• 遇到整数：将当前位置开始的连续整数取出，放入nums中；
• 有新的操作符入栈时，先将栈中已有同等级的操作符和操作数进行计算，计算结果放入nums，直到操作符为空或者遇到左括号时，再入栈，后续再进行计算剩下的。

注意点：

1.第一个数可能为负数（-6）：这样第一个操作符可能被认为 '减号',计算时没有前面的数与之计算，可以再最开始就加入一个0，变成 0-6这样结果也正好为-6;

2.为了防止括号内出现的首个字符为运算符，将 (- 替换成 ( 0-， (+ 替换成 (0+。

代码：

class Solution {
    public int calculate(String s) {
        //定义两个栈，一个用来存放操作数，一个用来存放操作符
        Deque<Integer> nums = new ArrayDeque<>();
        Deque<Character> ops = new ArrayDeque<>();
        //为了防止第一个数出现负数,先将操作数栈中加入0
        nums.addLast(0);
        //将空格去掉
        s = s.replaceAll(" ", "");
        //将s转换成一个字符数组
        char[] cs = s.toCharArray();
        int n = cs.length;
        for(int i = 0; i < n; i++){
            char c = cs[i];
            //如果遇到左括号，就将操作符加入栈中
            if(c == '('){
                ops.addLast(c);
            }else if(c == ')'){
                while(!ops.isEmpty()){
                    char op = ops.peekLast();
                    //如果不是左括号，就将括号内的数和操作符进行计算
                    if(op != '('){
                        calc(nums, ops);
                    }else{
                        //如果是左括号，就将左括号弹出
                        ops.pollLast();
                        break;
                    }
                }    
            }else{
                if(isNum(c)){
                    //定义当前整数
                    int num = 0;
                    int j = i;
                    //从i位开始后面的连续数字整体取出，加入到栈nums中
                    while(j < n && isNum(cs[j])){
                        num = num * 10 + (int)(cs[j++] - '0');
                    }
                    nums.addLast(num);
                    i = j - 1;
                }else{
                    //将（-和(+  替换成 (0-和(0+
                    if(i > 0 && (cs[i-1] == '(' || cs[i-1] == '+' || cs[i-1] == '-')){
                        nums.addLast(0);
                    }
                    //有新操作符入栈，先把栈内元素算出，直到没有操作符或遇到左括号，再入栈
                    while(!ops.isEmpty() && ops.peekLast() != '('){
                        calc(nums, ops);
                    }
                    ops.addLast(c);
                }    
            }
        }
            //算剩下的
        while(!ops.isEmpty()){
            calc(nums, ops);
        }
        return nums.peekLast();
    }


        //定义一个方法用于计算
        void calc(Deque<Integer> nums, Deque<Character> ops){
            //如果操作数不足以及无操作符，则无法计算
            if(nums.isEmpty() || nums.size() < 2) return;
            if(ops.isEmpty()) return;
            //取出栈顶元素和操作符进行计算
            int b = nums.pollLast(), a = nums.pollLast();
            char op = ops.pollLast();
            nums.addLast(op == '+' ? a+b : a-b);
        }
        //判断字符是否为数字
        boolean isNum(char c){
            return Character.isDigit(c);
        }
    }

一些注解：

if(isNum(c)){
    //定义当前整数
     int num = 0;
     int j = i;
    //从i位开始后面的连续数字整体取出，加入到栈nums中
      while(j < n && isNum(cs[j])){
         num = num * 10 + (int)(cs[j++] - '0');
       }
      nums.addLast(num);
      i = j - 1;

• num = num * 10 + (int)(cs[j++] - '0')：就像取出像23,569这种超过一位数的整数；
• i = j - 1：例如 56+,i从0开始（利用另一个变量j这里来替换一下i），当i为2时就已经不是数字了，整个for循环就结束了，for循环中就会i++,i == 3,就会跳过56后面的加号，所以if这里面就会将i回退一个指向6,后面for循环i++就会刚好到加号的位置。

  //将（-和(+  替换成 (0-和(0+
 if(i > 0 && (cs[i-1] == '(' || cs[i-1] == '+' || cs[i-1] == '-')){
       nums.addLast(0);
}

为了规避一些 ‘不合法的计算表达式’，例如 (+5-6) 变成 (0+5-6)

小知识：

Deque双端队列这种数据结构很灵活，即可以满足队列的FIFO(先进先出)特性，又可以满足栈的LIFO(后进先出)特性，那么分别作为队列和栈，Deque类常用的方法：