1、实现思路
- 创建两个栈:数据栈(numStack)和符号栈(operStack);
- 通过index索引来遍历表达式;
- 如果扫描到的是数字,就直接入栈。不能扫描到一个数就立刻入栈,因为它可能是多位数。需向expression表达式的index后看一位,如果是数就继续后移扫描,直到扫到符号才入栈。
- 如果扫描到的是操作符,则需要分情况考虑;
- 如果发现当前的符号栈为空,就直接入栈;
- 如果符号栈有操作符,就进行比较:① 如果当前操作符的优先级小于等于栈顶操作符,就从数据栈中pop出两个数据,从符号栈中pop出一个符号,运算后将其结果放入数据栈,最后将当前操作符放入符号栈;② 如果当前操作符的优先级大于栈顶操作符,就直接放入符号栈;
- 当表达式扫描完毕,就顺序的从数据栈和符号栈中pop出相应的数据和操作符并运算;
- 最后数据栈中只有一个数字,就是表达式的计算结果。
2、Java代码
package DataStructures.Stack;
/**
* @author yhx
* @date 2020/09/18
*/
public class Calculator {
public static void main(String[] args) {
String expression = "30+3*6-2";
//创建两个栈,一个数栈,一个符号栈
ArrayStack2 numStack = new ArrayStack2(10);
ArrayStack2 operStack = new ArrayStack2(10);
//定义需要的变量
//索引
int index = 0;
//数、操作符、运算结果
int num1, num2, oper, res;
//扫描缓存
char ch;
//用于多位数字的拼接
String keepNum = "";
//循环扫描expression每一个字符
do {
//依次得到expression的每个字符
ch = expression.substring(index, index + 1).charAt(0);
//判断ch是数据还是操作符
//如果是符号
if (operStack.isOper(ch)) {
//判断当前的符号栈是否为空
if (!operStack.isEmpty()) {
//如果不为空,需对数据处理
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 {
//处理多位数,如果ch已经是expression的最后一位,就直接入栈,无需再向后扫描,否则会越界
keepNum += ch;
if (index == expression.length() - 1) {
//Integer.parseInt(String)的作用就是将String字符类型数据转换为Integer整型数据
numStack.push(Integer.parseInt(keepNum));
} else {
final int INDEX1 = index + 1;
final int INDEX2 = index + 2;
//判断index后面是否是符号
if (operStack.isOper(expression.substring(INDEX1, INDEX2).charAt(0))) {
//如果后一位是操作符,则将keepNum入栈
numStack.push(Integer.parseInt(keepNum));
//入栈后要将keepNum清空
keepNum = "";
}
}
}
//让index+1,并判断是否扫描到expression的最后
index++;
} while (index < expression.length());
//扫描完毕后,符号栈中只存在最低优先级的加和减,只需pop字符和数字运算即可
while (!operStack.isEmpty()) {
//如果符号栈为空,则计算完成,数据栈存在最后一个数据,即运算结果
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);
}
//数据栈存在最后一个数据,即运算结果
int res2 = numStack.pop();
System.out.printf("表达式%s = %d", expression, res2);
}
}
/**
* 栈类,存放数据或符号,并含有一些操作相关的方法函数
*/
class ArrayStack2 {
private final int maxSize;
private final int[] stack;
private int top = -1;
/**
* 定义加减乘除符号的常量
*/
private final char MULTI;
private final char DIVI;
private final char ADD;
private final char SUB;
/**
* @param maxSize 栈的最大尺寸
*/
public ArrayStack2(int maxSize) {
this.maxSize = maxSize;
//数组模拟栈,数据就存在该数组中
stack = new int[this.maxSize];
MULTI = '*';
DIVI = '/';
ADD = '+';
SUB = '-';
}
/**
* 栈满
*
* @return 是否栈满
*/
public boolean isFull() {
//当数组顶位标记达到数组最大尺寸,即栈满
return top == maxSize - 1;
}
/**
* 栈空
*
* @return 栈是否为空
*/
public boolean isEmpty() {
//当数组顶位值等于默认值-1,即栈空
return top == -1;
}
/**
* 入栈
*
* @param value 要存入的数据
*/
public void push(int value) {
if (isFull()) {
System.out.println("栈满");
return;
}
top++;
stack[top] = value;
}
/**
* 出栈:将栈顶的数据返回
*
* @return 栈顶数据
*/
public int pop() {
if (isEmpty()) {
//抛出异常,同时返回
throw new RuntimeException("栈空,没有数据");
}
int value = stack[top];
top--;
return value;
}
/**
* @return 查看栈顶的值,但不是pop
*/
public int peek() {
return stack[top];
}
/**
* 返回运算符的优先级
*
* @param oper java中int和char可以混用,oper代表传入的数据或者操作符
* @return 数字越大优先级越高
*/
public int priority(int oper) {
if (oper == MULTI || oper == DIVI) {
return 1;
} else if (oper == ADD || oper == SUB) {
return 0;
} else {
//假定目前的表达式只有加减乘除
return -1;
}
}
/**
* 判断要处理的对象是数字还是运算符
*
* @param val 对象
* @return 1是运算符,0是数字
*/
public boolean isOper(char val) {
return val == MULTI || val == DIVI || val == ADD || val == SUB;
}
/**
* 计算方法
*
* @param num1 加数/减数/因数/除数
* @param num2 加数/被减数/因数/被除数
* @param oper 操作符
* @return 返回运算后的结果
*/
public int cal(int num1, int num2, int oper) {
int res = 0;
switch (oper) {
case '+':
res = num1 + num2;
break;
case '-':
res = num2 - num1;
break;
case '*':
res = num1 * num2;
break;
case '/':
res = num2 / num1;
break;
default:
break;
}
return res;
}
}
3、运行结果
表达式30+3*6-2 = 46