Java数据结构与算法———（22）用Java写一个栈，并用来计算中缀表达式（操作数是一位数）

用Java手写一个栈，并用这个栈计算中缀表达式，缺点是操作数只能是一位数。

一、代码

package stack;

public class Calculator {

	public static void main(String[] args) {
		// 定义一个字符串用于存放表达式
		String expression = "3+2*7-2";//中缀表达式
		// 创建两个栈，一个是数栈，一个是符号栈
		ArrayStack1 numStack = new ArrayStack1(10);
		ArrayStack1 operStack = new ArrayStack1(10);
		// 定义需要德相关变量
		int index = 0;// 用于扫描表达式
		int num1 = 0;
		int num2 = 0;
		int oper = 0;// 操作符
		int res = 0;// 每次运算后的结果
		char ch = ' ';// 将每次扫描得到的char保存到ch中
		// 开始用while循环扫描表达式
		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())) {
						oper = operStack.pop();
						num1 = numStack.pop();
						num2 = numStack.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);//ch本质是个字符，比如'1'，要将其转换成数字1，用'1'-48=1
			}
			//让index+1，并判断是否扫描到表示式expression的最后
			index++;
			if(index >= expression.length()) {
				break;//退出循环，扫描结束
			}
		}
		//当表达式扫描完毕，就顺序地从数栈和符号栈中pop出相应的数和符号，并计算
		while(true) {
			//如果符号栈为空，则计算出了最后的结果，数栈中只有一个数字，就是计算结果
			if(operStack.isEmpty()) {
				break;
			}
			//如果符号栈不为空，就顺序地从数栈和符号栈中pop出相应的数和符号，并计算
			num1 = numStack.pop();
			num2 = numStack.pop();
			oper = operStack.pop();
			res = numStack.cal(num1, num2, oper);//最后的计算结果
			numStack.push(res);
		}
		//将数栈中最后的数pop出，就是计算结果
		res = numStack.pop();
		System.out.printf("表示式 %s = %d\n", expression, res);
	}

}

//首先用数组创建一个栈
class ArrayStack1 {
	private int maxSize;// 栈的大小
	private int top = -1;// 栈顶指针，初始值为-1，表示栈中没有数据
	private int[] stack;// 数组模拟栈，用于存放数据。此处只是声明了一个引用变量 stack

	// 构造方法
	public ArrayStack1(int maxSize) {
		this.maxSize = maxSize;
		stack = new int[this.maxSize];// 这里才是在内存中创建了一个数组对象来模拟栈
	}

	// 判断栈空
	public boolean isEmpty() {
		return top == -1;
	}

	// 判断栈满
	public boolean isFull() {
		return top == maxSize - 1;
	}

	// 入栈 push
	public void push(int value) {
		// 先判断是否栈满
		if (isFull()) {
			System.out.println("沾满，不能添加数据");
			return;// 结束方法
		}
		// 栈没满
		top++;
		stack[top] = value;
	}

	// 返回当前栈顶值，但不出栈
	public int peek() {
		return stack[top];
	}

	// 出栈 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(int val) {
		return val == '+' || val == '-' || val == '*' || val == '/';
	}

	// 计算方法
	public int cal(int num1, int num2, int oper) {
		int sum = 0;// sum用于存放计算结果
		switch (oper) {
		case '+':
			sum = num1 + num2;
			break;
		case '-':
			sum = num2 - num1;// 注意顺序
			break;
		case '*':
			sum = num1 * num2;
			break;
		case '/':
			sum = num2 / num1;// 注意顺序
			break;
		default:
			break;
		}
		return sum;
	}
}

二、结果

表示式 3+2*7-2 = 15