227 基本计算器 II

声明：参考labuladong在力扣中的解法
参考labuladong力扣详细解法

题目

实现一个基本的计算器来计算一个简单的字符串表达式的值。

字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。

示例1

输入: “3+2*2”
输出: 7

示例2

输入: " 3/2 "
输出: 1

示例3

输入: " 3+5 / 2 "
输出: 5

思路

解决复杂问题时，需要将复杂问题拆成一个个小问题，然后逐个击破

我们最终要实现的计算器功能如下

1、输入一个字符串，可以包含+ - * /、数字、括号以及空格，你的算法返回运算结果。

2、要符合运算法则，括号的优先级最高，先乘除后加减。

3、除号是整数除法，无论正负都向 0 取整（5/2=2，-5/2=-2）。

4、可以假定输入的算式一定合法，且计算过程不会出现整型溢出，不会出现除数为 0 的意外情况。

拆解如下

1、字符串转整数

string s = "458";

int n = 0;
for (int i = 0; i < s.size(); i++) {
    char c = s[i];
    n = 10 * n + (c - '0');
}
// n 现在就等于 458

2、处理加减法

以1-12+3为例，思路是：

1、先给第一个数字加一个默认符号+，变成+1-12+3。

2、把一个运算符和数字组合成一对儿，也就是三对儿+1，-12，+3，把它们转化成数字，然后放到一个栈中。

3、将栈中所有的数字求和，就是原算式的结果。

int calculate(string s) {
    stack<int> stk;
    // 记录算式中的数字
    int num = 0;
    // 记录 num 前的符号，初始化为 +
    char sign = '+';
    for (int i = 0; i < s.size(); i++) {
        char c = s[i];
        // 如果是数字，连续读取到 num
        if (isdigit(c)) 
            num = 10 * num + (c - '0');
        // 如果不是数字，就是遇到了下一个符号，
        //如果下一个符号是空格，就跳过
        if ('c' == ' ') {
            continue;
        }
        // 下一个符号不是数字也不是空格，之前的数字和符号就要存进栈中
        if (!isdigit(c) || i == s.size() - 1 || ) {
            switch (sign) {
                case '+':
                    stk.push(num); break;
                case '-':
                    stk.push(-num); break;
            }
            // 更新符号为当前符号，数字清零
            sign = c;
            num = 0;
        }
    }
    // 将栈中所有结果求和就是答案
    int res = 0;
    while (!stk.empty()) {
        res += stk.top();
        stk.pop();
    }
    return res;
}

考虑到计算器中输入的空格，一般都不会影响我们的计算，忽略即可。

3、处理乘除法

思路是，乘除法优先于加减法计算，遇到乘除符号就将数值先计算出来再入栈
，栈中就完全是加减法的计算了

以2-3*4+5为例

比如上述例子就可以分解为+2，-3，*4，+5几对儿，我们刚才不是没有处理乘除号吗，很简单，其他部分都不用变，在switch部分加上对应的 case 就行了：

for (int i = 0; i < s.size(); i++) {
    char c = s[i];
    if (isdigit(c)) 
        num = 10 * num + (c - '0');

    if (!isdigit(c) || i == s.size() - 1) {
        switch (sign) {
            int pre;
            case '+':
                stk.push(num); break;
            case '-':
                stk.push(-num); break;
            // 只要拿出前一个数字做对应运算即可
            case '*':
                pre = stk.top();
                stk.pop();
                stk.push(pre * num);
                break;
            case '/':
                pre = stk.top();
                stk.pop();
                stk.push(pre / num);
                break;
        }
        // 更新符号为当前符号，数字清零
        sign = c;
        num = 0;
    }
}

4、处理括号

由于括号具有递归性质，以字符串3*(4-5/2)-6为例
calculate（3*(4-5/2)-6）
= 3 * calculate(4-5/2) - 6
= 3 * 2 - 6
= 0

因此，无论多少层括号嵌套，通过 calculate 函数递归调用自己，都可以将括号中的算式化简成一个数字。

递归条件：
遇到(开始递归，遇到)结束递归

for (int i = 0; i < s.size(); i++) {
    char c = s[i];
    if (isdigit(c)) 
        num = 10 * num + (c - '0');

    if (!isdigit(c) || i == s.size() - 1) {
        switch (sign) {
            int pre;
            case '+':
                stk.push(num); break;
            case '-':
                stk.push(-num); break;
            // 只要拿出前一个数字做对应运算即可
            case '*':
                pre = stk.top();
                stk.pop();
                stk.push(pre * num);
                break;
            case '/':
                pre = stk.top();
                stk.pop();
                stk.push(pre / num);
                break;
             case '(':
                num =  calculate(s.substr(i));
            case ')':
                break;
        }
        // 更新符号为当前符号，数字清零
        sign = c;
        num = 0;
    }
}

因此最终整合起来的代码如下：

class Solution
{
public:
    int calculate(string s)
    {
        stack<int> stk;
        //记录表达式中的每个数字
        int num = 0;
        char sign = '+';
        for (int i = 0; i < s.size(); i++)
        {
            char c = s[i];
            if (isdigit(c))
            {
                num = 10 * num + (c - '0');
            }

           /* if (c == '(')
            {
                num = calculate(s.substr(i + 1));
            }*/

            if ((!isdigit(c) && c != ' ') || i == s.size() - 1)
            {
                switch (sign)
                {
                    int pre;
                case '+':
                    stk.push(num);
                    break;
                case '-':
                    stk.push(-num);
                    break;
                case '*':
                    pre = stk.top();
                    stk.pop();
                    stk.push(pre * num);
                    break;
                case '/':
                    pre = stk.top();
                    stk.pop();
                    stk.push(pre / num);
                    break;
                default:
                    break;
                }

                sign = c;
                num = 0;
            }

            /*if (c == ')')
            {
                break;
            }*/
        }
        int sum = 0;
        while (!stk.empty())
        {
            sum += stk.top();
            stk.pop();
        }
        return sum;
    }
};