[力扣系列]227.基本计算器Ⅱ解析（c++）

解法一：双栈

代码

class Solution {
public:
	int calculate(string s) {
		vector<int> nums;
		vector<char> ops;
		int tmp;
		if(s[0]=='-'|| s[0] == '+')nums.push_back(0);
		for (int i = 0; i < s.length(); i++) {
			if (s[i] >= '0' && s[i] <= '9') {
				tmp = 0;
				while ((s[i] >= '0' && s[i] <= '9') && (i < s.length())) {//读数
					tmp = tmp * 10 + (s[i] - '0');
					i++;
				}
				i--;
				while (!ops.empty() && (ops.back() == '*' || ops.back() == '/')) {
					tmp = cal(nums.back(), ops.back(), tmp);
					nums.pop_back();
					ops.pop_back();
				}
				nums.push_back(tmp);
			}
			else if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/') {
				ops.push_back(s[i]);
			}
		}
		tmp = nums.at(0);
		for (int i = 0; i < ops.size(); i++) {
			tmp = cal(tmp, ops.at(i), nums.at(i + 1));
		}
		return tmp;
	}
	int cal(int a, char op, int b) {
		switch (op) {
		case '+':
			return a + b;
		case '-':
			return a - b;
		case '*':
			return a * b;
		case '/':
			return a / b;
		}
		return 0;
	}
};

运行效率

• 执行用时：8 ms, 在所有 C++ 提交中击败了93.11%的用户
• 内存消耗：9.1 MB, 在所有 C++ 提交中击败了22.76%的用户

思路解析

• 用vector模拟两个栈，一个存数字，一个存运算符。
• 提取出数字时，判断运算符栈顶是不是‘*’或‘/’，是的话先计算再把计算结果压进栈；如果是‘+’或‘-’的话就不用管，直接进栈。
• 最后按从左到右的顺序遍历vector计算加减法的答案。（这一步就是不用stack用vector的原因。）

复杂度分析

时间复杂度：O(n)，其中 n 为字符串 s 的长度。需要遍历字符串 s 一次，计算表达式的值。

空间复杂度：O(2n)，其中 n 为字符串 s 的长度。空间复杂度主要取决于栈的空间，栈的元素个数不超过 n。

一个更好的解法：栈

思路¹

由于乘除优先于加减计算，因此不妨考虑先进行所有乘除运算，并将这些乘除运算后的整数值放回原表达式的相应位置，则随后整个表达式的值，就等于一系列整数加减后的值。

基于此，我们可以用一个栈，保存这些（进行乘除运算后的）整数的值。对于加减号后的数字，将其直接压入栈中；对于乘除号后的数字，可以直接与栈顶元素计算，并替换栈顶元素为计算后的结果。

具体来说，遍历字符串 s，并用变量presign 记录每个数字之前的运算符，对于第一个数字，其之前的运算符视为加号。每次遍历到数字末尾时，根据 presign来决定计算方式：

• 加号：将数字压入栈；
• 减号：将数字的相反数压入栈；
• 乘除号：计算数字与栈顶元素，并将栈顶元素替换为计算结果。

代码实现中，若读到一个运算符，或者遍历到字符串末尾，即认为是遍历到了数字末尾。处理完该数字后，更新 presign为当前遍历的字符。

遍历完字符串 s 后，将栈中元素累加，即为该字符串表达式的值。

复杂度分析

时间复杂度：O(n)，其中 n 为字符串 s 的长度。需要遍历字符串 s 一次，计算表达式的值。

空间复杂度：O(n)，其中 n 为字符串 s 的长度。空间复杂度主要取决于栈的空间，栈的元素个数不超过 n。

---

1. https://leetcode-cn.com/problems/basic-calculator-ii/solution/ji-ben-ji-suan-qi-ii-by-leetcode-solutio-cm28/ ↩︎