栈 （使用数组实现Java代码和使用栈实现综合计算器）

栈的简介

栈是一个先入后出的有序列表。
栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插大和删除的一端，为变化的一端，称为栈项(Top)，另一端为固定的一 端， 称为栈底(Bottom)。
根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

使用数组实现栈

栈的应用场景

1. 子程序的调用: 在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以
   回到原来的程序中。
2. 处理递归调用: 和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆
   栈中。
3. 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4. 二叉树的遍历。
5. 图形的深度 优先(depth- first)搜索法。

实现栈的思路分析

1. 使用数组来模拟栈
2. 定义一个top来表示栈顶，初始化为-1
3. 入栈的操作，当有数据加入到栈时，top++; stack[topl = data; .
4. 出栈的操作，int value = stack[top]; top–, return valuel

代码实现：
定义一个数组栈类ArrayStack，添加变量和构造方法

private int maxsize;
private int[] stack;// 使用数组模拟栈
private int top = -1;// 栈底，初始化为-1

public ArrayStack(int maxsize) {
	this.maxsize = maxsize;
	stack = new int[maxsize];// 初始化数组
}

编写栈的方法：判断栈满和栈空，当原先的top指向maxsize-1的地方表示top已经到了栈顶的位置，这个时候不能添加元素进栈，即栈满、当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()) {
		// return -1;
		throw new RuntimeException("栈空");	
	}
	int value = stack[top];
	top--;
	return value;
}

栈的遍历

// 栈的遍历
public void show() {
	// 从栈顶往栈底遍历
	if (isEmpty()) {
		System.out.println("栈空");
		return ;
	}
	for (int i = top; i >= 0; i--) {
		System.out.println("第" + i + "个元素，值为：" + stack[i]);
	}
}

使用一个菜单进行测试：

// 创建一个栈实例
	ArrayStack ArrayStack = new ArrayStack(4);
	String key = "";
	boolean b = true;// 控制是否退出菜单
	Scanner sc = new Scanner(System.in);
	while (b) {
		System.out.println("show : 显示栈 ");
		System.out.println("exit : 退出程序");
		System.out.println("push : 入栈 ");
		System.out.println("pop  : 出栈 ");
		System.out.println("请输入key:");
		key = sc.next();
		switch (key) {
		case "show":
			ArrayStack.show();
			break;
		case "push":
			System.out.println("请输入一个数：");
			int value = sc.nextInt();
			ArrayStack.push(value);
			break;
		case "pop":
			try {
				int res = ArrayStack.pop();
				System.out.println("出栈的数据：" + res);
			} catch (Exception e) {
				System.out.println(e.getMessage());
			}
			break;
		case "exit":
			sc.close();
			b = false;
			break;
		default:
			System.out.println("输入有误！");
			break;
		}
	}
	System.out.println("程序退出！");

使用栈完成表达式的计算思路

1.通过一个index值(索引) ,来遍历我们的表达式
2.如果我们发现是一个数字，就直接入数栈
3.如果发现扫描到是一个符号,就分如下情况
3.1如果发现当前的符号栈为空，就直接入栈
3.2如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈。
4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号,并运行.
5.最后在数栈只有一个数字,就是表达式的结果
如下图所示：

在原先的基础上添加方法，在这篇文章上做修改
在固有的入栈出栈的基础上还需要添加以下方法，

判断符号的优先级

// 返回运算符的优先级，返回值的优先级越大值越高
	public int priority(int oper) {
		if (oper == '*' || oper == '/') {
			return 1;
		} else if (oper == '+' || oper == '-') {
			return 0;
		} else {
			return -1;
		}
	}

判断字符是不是运算符

	public boolean isOper(char value) {
		return value == '+' || value == '-' || value == '/' || value == '*';
	}

计算方法

public int cal(int a, int b, int oper) {
	int res = 0;// 结果
	switch (oper) {
	case '+':
		res = a + b;
		break;
	case '-':
		res = b - a; // 顺序
		break;
	case '/':
		res = b / a;
		break;
	case '*':
		res = a * b;
		break;
	default:
		break;
	}
	return res;
}

查看栈顶元素

	public int peek() {
		return stack[top];
	}

在测试类当中定义使用到的变量

String experssion = "1+2*4/2";
// 创建数栈和符号栈
ArrayStack2 NumStack = new ArrayStack2(10);
ArrayStack2 OperStack = new ArrayStack2(10);
// 定义用于扫描的索引
int index = 0;
int a = 0;	//用于计算的俩个数
int b = 0;
int oper = 0;	//用于存放运算符
int res = 0;	//运算结果
char ch = ' ';	// 扫描得到的字符

使用一个while循环对字符串进行处理

// 循环扫描experssion
while (true) {
	// 依次得到experssion的每一个字符
	ch = experssion.substring(index, index + 1).charAt(0);
	// 判断是数字还是符号
	if (OperStack.isOper(ch)) {
		// 判断符号栈是否为空
		if (!OperStack.isEmpty()) {
			// 符号栈不为空进行运算符比较
			/*
			 * 如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符， 
			 * 就需要从数栈中pop出两个数在从符号栈中pop出一个符号，进行运算，
			 * 将得到结果，入数栈，然后将当前的操作符入符号栈， 
			 * 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈。
			 */
			if (OperStack.priority(ch) <= OperStack.priority(OperStack.peek())) {
				a = NumStack.pop();
				b = NumStack.pop();
				oper = OperStack.pop();
				res = NumStack.cal(a, b, oper);
				// 运算完成后入数栈
				NumStack.push(res);
				// 把当前符号入符号栈
				OperStack.push(ch);
			} else {
				OperStack.push(ch);
			}
		} else {
			// 为空，直接入栈
			OperStack.push(ch);
		}
	}else {
		//扫描结果，如果是数字，直接入数栈
		//扫描到的ch是一个字符，在ASCII码表当中，数字和字符之间相差48		
		NumStack.push(ch-48);
	}	
	//判断是否扫描完成
	index++;
	if (index>=experssion.length()) {
		break;
	}
}

把最后留在数栈和符号栈当中的数字和字符进行处理

//当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号,并运行.
while(true) {
	//如果符号栈为空，计算最后的结果，此时数栈当中的数就是运算结果
	if (OperStack.isEmpty()) {
		break;
	}
		a = NumStack.pop();
		b = NumStack.pop();
		oper = OperStack.pop();
		res = NumStack.cal(a, b, oper);
		NumStack.push(res);
	}
System.out.println("表达式 "+experssion+" 的结果是："+NumStack.pop());
}

最后就是运行结果图：

存在的问题：一次只能读取一个数字，所以只能进行10以内的运算

如何修改呢？在原先的代码当中在未判断后面一个字符还是不是一个数字的时候，是直接就入栈的，在这里添加判断语句即可；

修改这个else当中的代码使其对后续的字符进行判断。以及在最开始添加一个变量keepnum；

String keepnum = "";// 用于处理多位数

// 扫描结果，如果是数字，直接入数栈
// 发现是数的时候直接入栈，不能发现一个数字后需要判断是不是多位数，并且对单个数字进行拼接
keepnum += ch;
// 如果ch是最后一位，直接入栈，防止后方代码数组越界
if (index == experssion.length() - 1) {
	NumStack.push(Integer.parseInt(keepnum));
} else {
	// 判断后一个是不是数字
	if (OperStack.isOper(experssion.substring(index + 1, index + 2).charAt(0))) {
		// 后一位是符号
		NumStack.push(Integer.parseInt(keepnum));
		// 清空keepnum
		keepnum = "";
	}
}

修改之后就可以进行多位数之间的运算了。