中缀表达式计算器(仅支持加减乘除,不支持小括号)

思路以及代码

package com.atguigu.stack;
//数的加减乘除，使用栈，中缀表达式，不包含小括号
public class Calculator {
//	使用栈完成计算一个表达式的结果
//	使用栈完成表达式的计算思路
//	1. 通过一个index值（索引），来遍历我们的表达式
//	2. 如果我们发现是一个数字，就直接入数栈，
//	3. 如果发现扫描到的是一个符号，就分如下情况
//	    1. 如果当前的符号栈为空，就直接入栈
//	    2. 如果符号栈有操作符，就进行比较，
//		如果当前的操作符的优先级小于或者等于栈中的操作符，
//		就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，
//		进行运算，将得到的结果，入数栈，然后将当前的操作符入符号栈；
//		如果当前的操作符的优先级大于或者等于栈中的操作符，
//		就直接入符号栈
//	4. 当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行。
//	5.最后在数栈中只有一个数字，就是表达式的结果

	public static void main(String[] args) {
		//根据前面思路，完成表达式的运算
		String expression = "11*11+9-30";//20//如何处理多位数的问题？
		//创建两个栈，数栈，符号栈
		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.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+3" '1'==49;'1'=>1
				//1.当处理多位数时，不能发现是一个数就立即入栈，因为它可能是多位数
				//2.在处理数时，需要向expression的表达式的index后再看一位，如果是数就进行扫描，如果是符号才入栈
				//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 = "1" 或者 "123"
						numStack.push(Integer.parseInt(keepNum));
						//重要的！！！！！，keepNum清空
						keepNum = "";
					}
				}
			}
			//让index + 1，并判断是否扫描到expression最后。
			index++;
			if(index >= expression.length()) {
				//说明index到达了最后
				break;
			}
		}
		
		//当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行。
		while(true) {
			//如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
			if(operStack.isEmpty()) {
				break;
			} else {
				num1 = numStack.pop();
				num2 = numStack.pop();
				oper = operStack.pop();
				res = numStack.cal(num1, num2, oper);
				numStack.push(res);//入栈
			}
		}
		//将数栈的最后数pop出，就是结果
		int res2 = numStack.pop();
		System.out.printf("表达式 %s = %d", expression, res2);
	}

}

//先创建一个栈，直接使用创建好的
//定义一个类ArrayStack2表示栈，需要扩展功能（查看栈顶，优先级，是否是运算符，计算方法）
class ArrayStack2{
	private int maxSize;//栈的大小
	private int[] stack;//数组，数组模拟栈，数据就放在该数组
	private int top = -1;//top表示栈顶，初始化为-1
	
	//构造器
	public ArrayStack2(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;
	}
	
	//入栈-push
	public void push(int value) {
		//先判断栈是否满
		if(isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}
	
	//出栈-pop,将栈顶的数据返回
	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 == '/';
	}
	//计算方法，（java中char和int是可以混用的
	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 = num1 / num2;
			break;
		default:
			break;
		}
		return res;
	}
	
}

结果截图