使用完成一个表达式的计算
实现思路:
先创建两个栈,一个数字栈(numstack),一个字符栈(operstack)
1.通过一个index值(索引),来遍历表达式,
2.如果我们发现的是一个数字就直接放入数字栈中。
3.如果发现的是一个运算符:
3.1.如果栈中为空就直接入栈。
3.2.如果符号栈中有运算符,就进行比较,
如果当前的运算符优先级小于或等于栈中的运算符,就需要从数字栈中pop两个数字,再从字符栈中pop出一个字符,进行运算,将得到的结果,入数栈,然后将当前的操作符入符号栈,
如果当前的操作符的优先级大于栈中的操作符则直接入栈。
4.当表达式扫描完毕,就顺序的从数栈和符号栈中pop出相应的数和符号,并进行运算。
5.最后当数字中只剩下一个数字时就是表达式的结果
图例:
创建一个栈
class ArrayStack2 {
private int maxsize;//表示栈的大小
private int[] stack;//数组模拟栈,数据存储在数组中
private int top;//代表栈顶,初始值-1
//构造器
public ArrayStack2(int maxsize) {
this.maxsize = maxsize;
this.stack = new int[maxsize];
top = -1;
}
//判断栈满
public boolean isFull() {
return top == maxsize - 1;
}
//判断栈空
public boolean isEmpth() {
return top == -1;
}
/**
* 增加返回栈顶数据的方法,只是查看并不是出栈
*/
public int peek() {
return stack[top];
}
/**
* 创建入栈的方法
*/
public void Push(int value) {
//先判断栈是否为满
if (isFull()) {
//为满则不添加数据
System.out.println("栈满");
return;
}
top++;
stack[top] = value;
}
/**
* 创建出栈的方法
*/
public int Pop() {
//先判断栈是否为空
if (isEmpth()) {
//抛出异常
throw new RuntimeException("栈空");
}
int value = stack[top];
top--;
return value;
}
/**
* 创建遍历栈的方法
*/
public void list() {
//判断是否为空
if (isEmpth()) {
System.out.println("栈空");
return;
}
//从栈顶开始遍历
for (int i = top; i >= 0; i--) {
System.out.println("stack key:" + i + "valve" + 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;//存储值
switch (oper) {
case '+':
res = num1 + num2;
break;
case '-':
res = num2 - num1;//注意顺序
break;
case '*':
res = num1 * num2;
break;
case '/':
res = num2 / num1;
break;
default:
System.out.println("错误");
break;
}
return res;
}
}
代码实现
//定义一个表达式
String expression = "30+200*6-20000";
//创建两个栈,数字栈和字符栈
ArrayStack2 NumStack = new ArrayStack2(10);
ArrayStack2 OperStack = new ArrayStack2(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.isEmpth()) {
// 如果符号栈中有运算符,就进行比较,
//
//如果当前的运算符优先级小于或等于栈中的运算符,就需要从数字栈中pop两个数字,
// 再从字符栈中pop出一个字符,进行运算,将得到的结果,入数栈,然后将当前的操作符入符号栈,
if (OperStack.priority(ch) <= OperStack.priority(OperStack.peek())) {
num1 = NumStack.Pop();//取出数字栈的第一个栈放入num1
num2 = NumStack.Pop();//取出数字栈的第二个栈放入num2
oper = OperStack.Pop();//取出字符栈的第一个栈放入oper
res = NumStack.cal(num1, num2, oper);
//把计算的结果放入数字栈中
NumStack.Push(res);
//将当前的运算符放入符号栈
OperStack.Push(ch);
} else {
//如果当前的操作符的优先级大于栈中的操作符则直接入栈。
OperStack.Push(ch);
}
} else {
//如果栈中为空就直接入栈。
OperStack.Push(ch);
}
} else {//如果是数字,直接入数栈
//特别注意
//1.当处理多位数时,不能只取一位就入栈
//2.在处理数,需要再向expression的表达式后一位查看,如果是数字就还要继续扫描,如果为字符才入栈
//3.因此我们需要定义一个变量,用于拼接
//处理多位数
keepNum += ch;
//如果ch已经是expression表达式的最后一位则直接入栈
if (index == expression.length() - 1) {
NumStack.Push(Integer.parseInt(keepNum));
} else {
//判断下一个字符是不是数字,如果是数字就暂时不入栈,如果下一位是字符则入栈;
//注意是看后一位,而不是index后移一位
if (OperStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
//如果后一位是运算符则入栈 ,将字符串keepNum转为数字在入栈
NumStack.Push(Integer.parseInt(keepNum));
//!注意keepNum在这里必须清空!
keepNum = "";
}
}
}
//index+1并判断是否扫描到表达式的最后
index++;
if (index >= expression.length()) {
break;
}
}
//当表达式扫描完毕,就顺序的从数栈和符号栈中pop出相应的数和符号,并进行运算。
//
//最后当数字中只剩下一个数字时就是表达式的结果
while (true) {
//如果符号栈为空,则计算到最后的结果,数字栈也就只剩一个结果了
if (OperStack.isEmpth()) {
break;
}
//优先级高的运算符已经在上一步中提前算完了,剩下的只需要从前往后算就可以
num1 = NumStack.Pop();
num2 = NumStack.Pop();
oper = OperStack.Pop();
res = NumStack.cal(num1, num2, oper);
NumStack.Push(res);
}
System.out.println(expression + " = " + NumStack.Pop());
}
效果展示
30+200*6-20000 = -18770