开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第十八天，点击查看活动详情
🤗前言：上文学习了栈 stack，今天带领大家使用栈实现综合案例-计算器
栈实现综合案例-计算器
思路分析 （使用中缀表达式）
计算式：7 * 2 * 2 - 5 + 1- 5 * 3 - 3
-
首先创建两个栈
- 数栈（numStack）：存放数
- 符号栈（operStack）：存放运算符
-
通过一个index 值，来遍历表达式
-
扫描到一个数字，就直接加入数栈
-
扫描到一个运算符，则有两种情况
- 若当前符号栈为空，就直接入栈
- 若符号栈不为空，就进行比较，如果当前的操作符的优先级 小于 或 等于 栈中的操作符，则从数栈中pop数两个数，再从符号栈中pop出一个符号，进行运算，将其结果进入数栈，将当前的操作符入符号栈
- 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
-
当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行
-
最后在数栈只有一个数字，既是结果
-
处理多位数问题
- 不能发现一个数就立即入栈，可能是多位数
- 处理数式，需要项expression的表达式的index，后看一位，若是数九进行扫描，若是符号才入栈
- 定义一个字符串变量，进行拼接
源码演示：
package com.stack;
/**
* @author Kcs 2022/8/12
*/
public class Calculator {
public static void main(String[] args) {
//扫描表达式
String expression = "5456*2+5";
//创建两个栈，数栈，符号栈
ArrayCalStack numStack = new ArrayCalStack(10);
ArrayCalStack operStack = new ArrayCalStack(10);
//扫描变量
int index = 0;
int num1 = 0;
int num2 = 0;
int oper = 0;
int res = 0;
//用于每次扫描得到的char保存到ch
char ch = ' ';
//用于拼接多位数
String keyNum = "";
//循环扫描
while (true) {
//依次得到每一个字符
ch = expression.substring(index, index + 1).charAt(0);
//判断是否为符号
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 {
//如果是数字就直接入数栈(存在多位数问题)
//处理多位数
keyNum += ch;
//如果ch为expression最后的一位
if (index == expression.length()-1){
numStack.push(Integer.parseInt(keyNum));
}else {
//判断下一位是否为数字，若为数字，则进行扫描，若是运算符，则入符号栈
if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))){
//如果后一位为运算符则入栈，keepNum ="112"
numStack.push(Integer.parseInt(keyNum));
//清空keepNum
keyNum = "";
}
}
}
//让index + 1 ,判断是否扫描到最后
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
int result = numStack.pop();
System.out.printf("表达式%s = %d", expression, result);
}
}
/**
* ArrayCalStack
*/
class ArrayCalStack {
/**
* 栈的的大小
*/
private int maxSize;
/**
* 数组模拟栈
*/
private int[] stack;
/**
* 初始化栈顶
*/
private int top = -1;
/**
* 构造方法
*/
public ArrayCalStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
/**
* 返回当前栈顶的值，但并不pop
*/
public int peek() {
return stack[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 var) {
return var == '+' || var == '-' || var == '*' || var == '/';
}
/**
* 计算方法
*/
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;
}
}
