题目大意
求一个非负整数四则混合运算且含嵌套括号表达式的值，即输入四则混合运算表达式，输出其值。如：
数据保证：(1)保证表达式合法（含除数不为0）；(2)保证运算数是非负整数。
# 输入：
1+2*(6/2)-4
# 输出：
3.0
双栈结构实现
符号优先级定义：')+-*/('；维护两个栈: 符号栈、数字栈；遍历输入串过程中计算：
- 数字直接入数字栈。
- 符号入栈的情况：
a. 符号栈为空时
b. 当前符号优先于栈顶符号时
c. 符号栈顶为
(时 - 需要出栈计算的情况: 符号栈顶是非
(的更高优先级符号时
class ExpStack {
private static final String LEVEL_OPTS = ")+-*/(";
public double solve(String input) {
Stack<Character> optStack = new Stack<>();
Stack<Double> numStack = new Stack<>();
int i = 0;
while (i < input.length()) {
// 如果当前是数字时直接入栈
if (Character.isDigit(input.charAt(i))) {
int t = 0;
for (; i < input.length() && Character.isDigit(input.charAt(i)); i++) {
t = t * 10 + input.charAt(i) - '0';
}
numStack.push((double) t);
} else {
// 如果当前是操作符时：
// 1.符号栈为空时直接，符号入栈
// 2.当前符号优先于栈顶符合时，符号入栈
// 3.符号栈顶为优先级最高的'('时，符号入栈
// 4.符号栈顶是非'('的更高级运算符时，出栈计算表达式
if (optStack.isEmpty() || compPriority(input.charAt(i), optStack.peek()) > 0) {
optStack.push(input.charAt(i++));
} else if (optStack.peek() == '(') { // 栈顶为左括号 '('
if (input.charAt(i) == ')') { // 当前时')'时，括号匹配完成，弹出'('
optStack.pop();
} else {
optStack.push(input.charAt(i));
}
i++;
} else {
// 栈顶优先级更高且非 '(' : 运算
double top = numStack.pop();
numStack.push(calc(numStack.pop(), optStack.pop(), top));
}
}
}
while (!optStack.isEmpty()) {
double top = numStack.pop();
numStack.push(calc(numStack.pop(), optStack.pop(), top));
}
return numStack.pop();
}
private int compPriority(char c1, char c2) {
return LEVEL_OPTS.indexOf(c1) - LEVEL_OPTS.indexOf(c2);
}
private double calc(double x, char o, double y) {
switch (o) {
case '+':
return x + y;
case '-':
return x - y;
case '*':
return x * y;
case '/':
return x / y;
}
return 0;
}
}
二叉树结构实现
构建二叉树：将符号作为非叶子节点，数字作为叶子结点。最后通过后序变量计算结果。使用二分法建树（根节点是表达式中最后一个计算的运算符，即后缀式中最后一个运算符）：
- 先排除括号（因为括号要看成一个整体）
- 优先取
+-（因为优先级更低，计算时间更晚） - 再考虑
*/（没有加减再考虑乘除）
class ExpTree {
private String mInput;
private java.util.LinkedList<Node> mTree;
public double solve(String input) {
mInput = input;
mTree = new java.util.LinkedList<>();
buildTree(0, mInput.length());
return dfs(mTree.size() - 1);
}
private int buildTree(int li, int ri) {
try { // 先尝试吧表达式解析为叶子节点(纯运算数)
int n = Integer.parseInt(mInput.substring(li, ri));
Node node = new Node(n, -1, -1);
mTree.addLast(node);
return mTree.size() - 1;
} catch (Exception ignore) {
}
// 找到最外层的运算符(最后一个计算的运算符,优先级最低的符号 opt)
int opt, as = -1, md = -1, bracket = 0;
for (int i = li; i < ri; i++) {
switch (mInput.charAt(i)) {
case '(':
bracket++;
break;
case ')':
bracket--;
break;
case '+':
case '-':
if (bracket == 0) {
as = i;
}
break;
case '*':
case '/':
if (bracket == 0) {
md = i;
}
break;
}
}
opt = as >= 0 ? as : md : as;
if (opt < 0) { // 发现这是一个被括号包裹的表达式(去掉括号重新构造)
return buildTree(li + 1, ri - 1);
}
// 依次构造左右子树
Node node = new Node(mInput.charAt(opt), buildTree(li, opt), buildTree(opt + 1, ri));
mTree.addLast(node);
return mTree.size() - 1;
}
private double dfs(int i) { // 后序遍历求解
if (mTree.get(i).lch == -1 && mTree.get(i).rch == -1) {
return mTree.get(i).num;
}
switch (mTree.get(i).opt) {
case '+':
return dfs(mTree.get(i).lch) + dfs(mTree.get(i).rch);
case '-':
return dfs(mTree.get(i).lch) - dfs(mTree.get(i).rch);
case '*':
return dfs(mTree.get(i).lch) * dfs(mTree.get(i).rch);
case '/':
return dfs(mTree.get(i).lch) / dfs(mTree.get(i).rch);
}
return 0;
}
private static class Node {
double num;
char opt;
int lch, rch;
Node(double n, int l, int r) {
num = n;
initChild(l, r);
}
Node(char o, int l, int r) {
opt = o;
initChild(l, r);
}
private void initChild(int l, int r) {
lch = l;
rch = r;
}
}
}
测试驱动
public class Main {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
String input = cin.nextLine();
double t = new ExpTree().solve(input);
System.out.println(t);
double s = new ExpStack().solve(input);
System.out.println(s);
}
}
