代码
public class Main {
public static void main(String[] args) {
int result = calExpression("100+2*4-6/3");
System.out.println(result);
}
public static int calExpression(String expression){
//数栈 符号栈
ArrayStack numStack = new ArrayStack(20);
ArrayStack operStack = new ArrayStack(20);
char oneChar;
int index = 0;
int result = 0;
String realNum = "";
while (true){
if (index == expression.length()){
System.out.println("表达式已全部入栈");
break;
}
oneChar = expression.charAt(index);
index++;
System.out.println(index);
System.out.println("oneChar:"+oneChar);
//判断是符号还是数字
if (isOper(oneChar)){
System.out.println("是符号");
//如果是符号
//先看看栈里面是否为空
if (operStack.isEmpty()){
//如果是空，则直接入栈
operStack.push(oneChar);
}else{
int operInStack = operStack.pop();//弹出栈的运算符
if (priority(oneChar) > priority(operInStack)){
//弹出的运算符优先级低，则直接入栈
operStack.push(operInStack);
operStack.push(oneChar);
}else {
int num1 = numStack.pop();
int num2 = numStack.pop();
numStack.push(calculate(num2, num1, operInStack));
operStack.push(oneChar);
}
}
}else {
//是数字，要判断是不是多位数
realNum = realNum + oneChar;//这个变量要定在外面
//如果此oneChar已经是最后一位了 则直接入栈 防止越界
if (index == expression.length()){
numStack.push(Integer.parseInt(realNum));//注意这里看看是否要转成ASCⅡ值，因为这里转成int了 所以就不用再减了
realNum = "";//一定要注意清空！！！
}else {
//如果不是最后一位，则往后看一位，看看是不是多位数
if (isOper(expression.charAt(index))){
//说明是符号,则入栈
numStack.push(Integer.parseInt(realNum) );//
realNum = "";//一定要注意清空！！！
}//如果不是单位数，则先不压栈，等realNum把这个数记全了之后一起压进去
}
}
}
while (true){
if (operStack.isEmpty()){
//符号栈为空，则结果已出
System.out.println("结果已经出来了");
break;
}else {
int oper = operStack.pop();
int num1 = numStack.pop();
int num2 = numStack.pop();
System.out.println("num1:"+num1);
System.out.println("num2:"+num2);
System.out.println("oper:"+oper);
System.out.println("结果："+calculate(num2, num1, oper));
numStack.push(calculate(num2, num1, oper));
}
}
result = numStack.pop();
return result;
}
//返回运算符的优先级，这个优先级是程序员自己定的
public static int priority(int oper){
if (oper == '*' || oper == '/'){
return 1;
}else if (oper == '+' || oper == '-'){
return 0;
}else {
return -1;//异常情况
}
}
//判断是不是一个运算符
public static boolean isOper(char val){
return (val == '*') || (val == '/') || (val == '+') || (val == '-');
}
//计算
public static int calculate(int num1,int num2,int oper){
int result = 0;
//要记住 switch的每一个case都要break
switch (oper){
case '+':
result = num1 + num2;
System.out.println("result:"+ result);
break;
case '-':
result = num1 - num2;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num1 / num2;
break;
default:
break;
}
System.out.println("result1:"+ result);
return result;
}
}
class ArrayStack{
int maxSize;
int top;//栈顶
int[] array;
ArrayStack(int maxSize){
this.maxSize = maxSize;
top = -1;
array = new int[maxSize];
}
//判断栈是否满了
public boolean isFull(){
return top == maxSize-1;
}
//判断栈是否为空
public boolean isEmpty(){
return top == -1;
}
//入栈
public void push(int item){
if (isFull()){
System.out.println("栈满了 无法入栈");
return;
}
array[top + 1] = item;
top++;
}
//出栈
public int pop(){
if (isEmpty()){
throw new RuntimeException("栈是空的");
}
int value = array[top];
top--;
return value;
}
//遍历栈
public void showStack(){
if (isEmpty()){
throw new RuntimeException("栈是空的");
}
int temp = top;
for (int i = temp;i >= 0;i--){
System.out.println(array[i]);
}
}
}
结果
1
oneChar:1
2
oneChar:0
3
oneChar:0
4
oneChar:+
是符号
5
oneChar:2
6
oneChar:*
是符号
7
oneChar:4
8
oneChar:-
是符号
result1:8
9
oneChar:6
10
oneChar:/
是符号
11
oneChar:3
表达式已全部入栈
num1:3
num2:6
oper:47
result1:2
结果：2
result1:2
num1:2
num2:8
oper:45
result1:6
结果：6
result1:6
num1:6
num2:100
oper:43
result:106
result1:106
结果：106
result:106
result1:106
结果已经出来了
106
Process finished with exit code 0
需要注意的地方
①思路要清晰
有两个栈，分别是符号栈和数栈
1.通过一个index 值（索引），来遍历我们的表达式
2.如果我们发现是一个数字,就直接入数栈（注意考虑多位数的情况）
3.如果发现扫描到一个符号,就分如下情况
- 3.1 如果发现当前的符号栈为空，就直接入栈
- 3.2 如果符号栈有操作符，就进行比较
- 3.2.1 如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中
pop出两个数在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈（注意，参与运算的是符号栈中的符号，而不是刚从表达式中取到的符号） - 3.2.2 如果当前的操作符的优先级大于栈中的操作符,就直接入符号栈
4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号,并计算
5.最后在数栈只有—个数字,就是表达式的结果
②switch的每一个case都需要break
③注意 字符’1’ 在ASCⅡ码表中并不是1，而是49。
④注意 变量的定义是否需要全局，如果是全局的话，是否需要在恰当时机进行清空。
