韩顺平讲的，用数组模拟栈，再用栈做一个简单的计算器https://www.bilibili.com/video/BV1E4411H73v?p=35
其中韩顺平给出的代码有一些问题，当计算形如A - B * C + D这种式子的时候结果会出错，比如计算：
5 - 2 * 3 + 1
计算结果为-2
原理大概是这样：因为正常的计算顺序是从左到右，但是用栈做的计算器的时候，计算是从式子右边往式子左边算的，这样当当遇到一个式子左边是负号这种情况，负号参与运算的顺序就会发生错误。
一个解决方法是在韩顺平给出的算法的基础上进行修改，思路是如果遍历字符串，发现下一位是负号，就将负号之后到下一个负号之间的数加一个负号，再把入符号栈栈顶的负号改成正号。
增加的代码：
if (operStack.top() != -1 && operStack.peek() == ‘-‘) {
keepNum += ch;
if (index == expression.length() - 1) {
numStack.push(- Integer.parseInt(keepNum));
keepNum = "";
operStack.modify(‘+‘);
} else {
//判断下一个字符是不是数字，如果是数字则继续扫描，如果是运算符，则入栈
if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
//如果后一位是运算符则入栈keepNum = "1"或"123"
numStack.push(- Integer.parseInt(keepNum));
//重要，还原keepNum
keepNum = "";
operStack.modify(‘+‘);
} else {
index++;
continue;
}
}
}
全部代码：
public class Calculator {
public static void main(String[] args) {
//完成表达式运算
String expression = "5-2*3+1"; //"5-2*3+1"
//创建两个栈，一个数栈，一个符号栈
ArrayStack numStack = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(10);
//定义需要的相关变量
int index = 0;//用于扫描
int num1 = 0;
int num2 = 0;
int oper = 0;
int res = 0;
char ch = ‘ ‘;//将每次扫描得到的char保存到ch
String keepNum = "";//用于拼接多位数
//开始用while循环扫描expression
while (true) {
//依次得到expression的每一个字符
ch = expression.substring(index, index + 1).charAt(0);
//判断ch是什么，然后做相应的处理
if (operStack.isOper(ch)) {//如果是运算符
//判断当前符号栈是否为空
if (!operStack.isEmpty()) {
//如果符号栈有操作符，就进行比较，如果当前的操作符优先级小于或等于栈中的操作符，就需要从数栈中pop两个数，再从符号栈中pop出一个符号，进行运算，得到结果，入数栈，然后将当前操作符入符号栈
if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
//把运算结果入数栈
numStack.push(res);
//然后把当前的操作符入符号栈
operStack.push(ch);
} else {
//如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
operStack.push(ch);
}
} else {
//如果为空，直接入符号栈
operStack.push(ch);
}
} else {//如果是数则直接入数栈
//numStack.push(ch - 48);//字符1转换为int 1
//分析思路：
//1. 当处理多位数时，不能发现是一个数就立即入栈，因为可能是多位数
//2. 在处理多位数，需要向expression的表达式的index后再看一位，如果是数就继续扫描，如果是符号才入栈
//3. 因此需要定义一个变量字符串，用于拼接
if (operStack.top() != -1 && operStack.peek() == ‘-‘) {
keepNum += ch;
if (index == expression.length() - 1) {
numStack.push(- Integer.parseInt(keepNum));
keepNum = "";
operStack.modify(‘+‘);
} else {
//判断下一个字符是不是数字，如果是数字则继续扫描，如果是运算符，则入栈
if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
//如果后一位是运算符则入栈keepNum = "1"或"123"
numStack.push(- Integer.parseInt(keepNum));
//重要，还原keepNum
keepNum = "";
operStack.modify(‘+‘);
} else {
index++;
continue;
}
}
} else {
//处理多位数
keepNum += ch;
//如果ch已经是expression的最后一位，就直接入栈
if (index == expression.length() - 1) {
numStack.push(Integer.parseInt(keepNum));
} else {
//判断下一个字符是不是数字，如果是数字则继续扫描，如果是运算符，则入栈
if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
//如果后一位是运算符则入栈keepNum = "1"或"123"
numStack.push(Integer.parseInt(keepNum));
//重要，还原keepNum
keepNum = "";
}
}
}
}
//让index + 1，并判断是否扫描到expression最后，如果是数字则继续扫描，如果是运算符，则入栈
index++;
if (index >= expression.length()) {
break;
}
}
//当表达式扫描完毕，就按顺序从数栈和符号栈中pop出相应的数和符号，并运行
while (true) {
//如果符号栈为空，则计算到最后的结果，数栈中只有一个数值
if (operStack.isEmpty()) {
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);//入栈
}
//将数栈pop出就是结果
System.out.printf("表达式%s = %d", expression, numStack.pop());
}
}
//使用前面创建的，需要扩展功能
class ArrayStack {
private int maxSize; //栈的大小
private int[] stack; //数组、数组模拟栈，数据就放在该数组
private int top = -1; //top表示栈顶，初始化为-1
//构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
//增加一个方法，可以返回当前栈顶的值，但不是真正的pop
public int peek() {
return stack[top];
}
//修改栈顶的值
public void modify (char val) {
stack[top] = val;
}
//返回栈顶
public int top() {
return top;
}
//栈满
public boolean isFull() {
return top == maxSize - 1;
}
//栈空
public boolean isEmpty() {
return top == -1;
}
//入栈
public void push(int value) {
//判断是否栈满
if (isFull()) {
System.out.println("栈满");
return;
}
top++;
stack[top] = value;
}
//出栈
public int pop() {
//先判断栈是否为空
if (isEmpty()) {
//抛出异常
throw new RuntimeException("栈空，没有数据");
}
int value = stack[top];
top--;
return value;
}
//显示栈的情况，遍历栈，遍历时，需要从栈顶开始显示数据
public void list() {
if (isEmpty()) {
System.out.println("栈空，没有数据");
return;
}
for (int i = top; i >= 0; i--) {
System.out.printf("stack[%d]=%d\n", i, stack[i]);
}
}
//返回运算符的优先级。优先级由程序员确定，优先级使用数字表示，数字越大优先级越高
public int priority(int oper) {
if (oper == ‘*‘ || oper == ‘/‘) {
return 1;
} else if (oper == ‘+‘ || oper == ‘-‘) {
return 0;
} else {
return -1;//假定目前只有加减乘除
}
}
//判断是不是一个运算符
public boolean isOper(char val) {
return val == ‘+‘ || val == ‘-‘ || val == ‘*‘ || val == ‘/‘;
}
//计算方法
public int cal(int num1, int num2, int oper) {
int res = 0;//res用于存放计算的结果
switch (oper) {
case ‘+‘:
res = num1 + num2;
break;
case ‘-‘:
res = num2 - num1;
break;
case ‘*‘:
res = num1 * num2;
break;
case ‘/‘:
res = num2 / num1;
break;
}
return res;
}
}
原文：https://www.cnblogs.com/LostSecretGarden/p/14691151.html