【表达式计算】双栈 : 表达式计算问题的通用解法
原创
©著作权归作者所有：来自51CTO博客作者宫水三叶的原创作品，请联系作者获取转载授权，否则将追究法律责任
题目描述
这是 LeetCode 上的 224. 基本计算器 ，难度为 困难。
Tag : 「表达式计算」
给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。
示例 1：
示例 2：
示例 3：
输入：s = "(1+(4+5+2)-3)+(6+8)"
提示：
-
s 由数字、'+'、'-'、'('、')'、和' ' 组成 -
s 表示一个有效的表达式
双栈
我们可以使用两个栈 nums 和 ops 。
-
nums ： 存放所有的数字 -
ops ：存放所有的数字以外的操作，+/- 也看做是一种操作
然后从前往后做，对遍历到的字符做分情况讨论：
- 空格 : 跳过
-
( : 直接加入ops 中，等待与之匹配的) -
) : 使用现有的nums 和ops 进行计算，直到遇到左边最近的一个左括号为止，计算结果放到nums - 数字 : 从当前位置开始继续往后取，将整一个连续数字整体取出，加入
nums -
+/- : 需要将操作放入ops 中。在放入之前先把栈内可以算的都算掉，使用现有的nums 和ops 进行计算，直到没有操作或者遇到左括号，计算结果放到nums
一些细节：
- 由于第一个数可能是负数，为了减少边界判断。一个小技巧是先往
nums 添加一个 0 - 为防止 () 内出现的首个字符为运算符，将所有的空格去掉，并将
(- 替换为(0-，(+ 替换为(0+（当然也可以不进行这样的预处理，将这个处理逻辑放到循环里去做）
Java 代码：
class Solution {
public int calculate(String s) {
// 存放所有的数字
Deque<Integer> nums = new ArrayDeque<>();
// 为了防止第一个数为负数，先往 nums 加个 0
nums.addLast(0);
// 将所有的空格去掉
s = s.replaceAll(" ", "");
// 存放所有的操作，包括 +/-
Deque<Character> ops = new ArrayDeque<>();
int n = s.length();
char[] cs = s.toCharArray();
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 u = 0, j = i;
// 将从 i 位置开始后面的连续数字整体取出，加入 nums
while (j < n && isNum(cs[j])) u = u * 10 + (int)(cs[j++] - '0');
nums.addLast(u);
i = j - 1;
} else {
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 {
returnC++ 代码：
class Solution {
public:
void replace(string& s){
int pos = s.find(" ");
while (pos != -1) {
s.replace(pos, 1, "");
pos = s.find(" ");
}
}
int calculate(string s){
// 存放所有的数字
stack<int> nums;
// 为了防止第一个数为负数，先往 nums 加个 0
nums.push(0);
// 将所有的空格去掉
replace(s);
// 存放所有的操作，包括 +/-
stack<char> ops;
int n = s.size();
for(int i = 0; i < n; i++) {
char c = s[i];
if(c == '(')
ops.push(c);
else if(c == ')') {
// 计算到最近一个左括号为止
while(!ops.empty()) {
char op = ops.top();
if(op != '(')
calc(nums, ops);
else {
ops.pop();
break;
}
}
}
else {
if(isdigit(c)) {
int cur_num = 0, j = i;
// 将从 i 位置开始后面的连续数字整体取出，加入 nums
while(j <n && isdigit(s[j]))
cur_num = cur_num*10 + (s[j++] - '0');
// 注意上面的计算一定要有括号，否则有可能会溢出
nums.push(cur_num);
i = j - 1;
}
else {
if (i > 0 && (s[i - 1] == '(' || s[i - 1] == '+' || s[i - 1] == '-')) {
nums.push(0);
}
// 有一个新操作要入栈时，先把栈内可以算的都算了
while(!ops.empty() && ops.top() != '(')
calc(nums, ops);
ops.push(c);
}
}
}
while(!ops.empty())
calc(nums, ops);
return nums.top();
}
void calc(stack<int> &nums, stack<char> &ops){
if(nums.size() < 2 || ops.empty())
return;
int b = nums.top(); nums.pop();
int a = nums.top(); nums.pop();
char op = ops.top(); ops.pop();
nums.push(op == '+'- 时间复杂度：
- 空间复杂度：
进阶
- 如果在此基础上，再考虑
* 和/，需要增加什么考虑？如何维护运算符的优先级？ - 在
的基础上，如果考虑支持自定义符号，例如a / func(a, b) * (c + d)，需要做出什么调整？
补充
- 对应进阶 1 的补充。
一个支持 + - * / ^ % 的「计算器」，基本逻辑是一样的，使用字典维护一个符号优先级：
class Solution {
Map<Character, Integer> map = new HashMap<>(){{
put('-', 1);
put('+', 1);
put('*', 2);
put('/', 2);
put('%', 2);
put('^', 3);
}};
public int calculate(String s) {
s = s.replaceAll(" ", "");
char[] cs = s.toCharArray();
int n = s.length();
Deque<Integer> nums = new ArrayDeque<>();
nums.addLast(0);
Deque<Character> ops = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
char c = cs[i];
if (c == '(') {
ops.addLast(c);
} else if (c == ')') {
while (!ops.isEmpty()) {
if (ops.peekLast() != '(') {
calc(nums, ops);
} else {
ops.pollLast();
break;
}
}
} else {
if (isNumber(c)) {
int u = 0;
int j = i;
while (j < n && isNumber(cs[j])) u = u * 10 + (cs[j++] - '0');
nums.addLast(u);
i = j - 1;
} else {
if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
nums.addLast(0);
}
while (!ops.isEmpty() && ops.peekLast() != '(') {
char prev = ops.peekLast();
if (map.get(prev) >= map.get(c)) {
calc(nums, ops);
} else {
break;
}
}
ops.addLast(c);
}
}
}
while (!ops.isEmpty() && ops.peekLast() != '(') 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();
int ans = 0;
if (op == '+') {
ans = a + b;
} else if (op == '-') {
ans = a - b;
} else if (op == '*') {
ans = a * b;
} else if (op == '/') {
ans = a / b;
} else if (op == '^') {
ans = (int)Math.pow(a, b);
} else if (op == '%') {
ans = a % b;
}
nums.addLast(ans);
}
boolean isNumber(char {
return- 关于进阶
，其实和进阶
对于非单个字符的运算符（例如 函数名function），可以在处理前先将所有非单字符的运算符进行替换（将 function 替换为 @# 等）
然后对特殊运算符做特判，确保遍历过程中识别到特殊运算符之后，往后整体读入（如 function(a,b) -> @(a, b)，@(a, b) 作为整体处理）
最后
这是我们「刷穿 LeetCode」系列文章的第 No.224 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。
在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：github.com/SharingSour… 。
在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。
