数据结构之栈
1.栈的一个实际需求
请输入一个表达式
计算式:[7*2*2-5+1-5+3-3]
请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算
计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)->栈
2.栈的介绍
1)栈的英文为(stack)
2)栈是一个先入后出(FILO-First In Last Out)的有序列表。
3)栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
4)根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
5)出栈(pop)和入栈(push)的概念(如图所示)
3.栈的应用场景
1)子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
2)处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
3)表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4)二叉树的遍历。图形的深度优先(depth一first)搜索法
4.栈的快速入门
1.用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来储存栈的数据内容。
2.实现思路分析,并画出示意图
package com.yt.stack;
import java.util.Scanner;
/**
* @auther yt
* @address https://www.cnblogs.com/y-tao/
*/
public class ArrayStackDemo {
public static void main(String[] args) {
//测试ArrayStack是否正确
//先创建一个ArrayStack对象，表示栈
ArrayStack arrayStack = new ArrayStack(4);
String key = "";
boolean loop = true;//控制是否退出菜单
Scanner scanner = new Scanner(System.in);
while (loop){
System.out.println("show:表示显示栈");
System.out.println("exit:表示退出程序");
System.out.println("push:表示入栈");
System.out.println("pop:表示出栈");
System.out.println("请输入你的选择");
key = scanner.next();
switch (key){
case "show":
arrayStack.list();
break;
case "push":
System.out.println("请输入一个数");
int value = scanner.nextInt();
arrayStack.push(value);
break;
case "pop":
int pop = arrayStack.pop();
System.out.printf("出栈的数据是 %d\n", pop);
break;
case "exit":
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出~~~");
}
}
//一.定义一个ArrayStack 表示栈
class ArrayStack{
private int maxSize;//栈的大小
private int[] stack;//数组模拟栈，数据就放在该数组中
private int top = -1;//top表示栈顶，初始化为-1
//构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
//栈满
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;
}
//出栈
public int pop(){
//先判断是否栈空
if (isEmpty()){
System.out.println("栈空");
return -1;
}
int value = stack[top--];
return value;
}
//遍历栈中的元素，遍历时从栈顶开始显示数据
public void list(){
//判断栈是否为空
if (isEmpty()){
System.out.println("栈空，没有数据");
}
for (int i = top; i >=0 ; i--) {
System.out.printf("stack[%d]=%d\n",i,stack[i]);
}
}
}
5.栈实现综合计算器
package com.yt.stack;
/**
* @auther yt
* @address https://www.cnblogs.com/y-tao/
*/
public class Calculator {
public static void main(String[] args) {
String expression = "60/3+7*2*2";
//创建两个栈，一个表示数栈，一个表示符号栈
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 = 0;//将每次扫描得到的char保存到ch,注意空串直接用零表示，否则会出错
String mulNum = "";//用于拼接多个数
//开始循环扫描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);
index++;
} else {
//当前扫描的操作符优先级大于符号栈中优先级，直接如符号栈
operStack.push(ch);
index++;
}
} else {
//符号栈为空，直接入栈
operStack.push(ch);
index++;
}
}else {//如果是数，直接如数栈
//注意，如果是多个数该怎么办呢？
// numStack.push(ch - 48);//数字0的ASCII码为48
//分析思路：
//1.当处理多位数时，不能立即即入数栈，因为其可能是多位数
//2.在处理数时，需要看当前扫描的数的后一位是数还是操作符，如果是数就继续扫描，如果是符号才入栈
//3.因此，定义一个字符串来保存多位数
//处理多位数
mulNum += ch;
//如果ch已经是expression的最后一位，就直接入栈
if (index == expression.length()-1){
numStack.push(Integer.parseInt(mulNum));
} else {
//判断下一个字符是不是数字，如果是数字就继续扫描，如果是运算符，则入栈
//注意：是看后一位，不是index++
if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))){
//如果后一位是运算符，直接将数字入数栈
numStack.push(Integer.parseInt(mulNum));
//易错点：要将mulNum清空
mulNum = "";
}
}
//让index+1，判断是否扫描到expression的最后
index++;
if (index >= expression.length()){
break;
}
}
}
//前面循环结束表示表达式已经扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号进行运算
while (true){
//如果符号栈为空，则计算到最后的结果，数栈中只有一个数字
if (operStack.isEmpty()){
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1,num2,oper);
numStack.push(res);
}
//将数栈的最后数取出就是结果
int res2 = numStack.pop();
System.out.printf("表达式%s = %d",expression,res2);
}
}
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];
}
//新增一个方法，可以返回栈顶的值，但是不将栈顶的值移除栈，即top不减1
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;
}
//出栈
public int pop(){
//先判断是否栈空
if (isEmpty()){
System.out.println("栈空");
return -1;
}
int value = stack[top--];
return value;
}
//遍历栈中的元素，遍历时从栈顶开始显示数据
public void list(){
//判断栈是否为空
if (isEmpty()){
System.out.println("栈空，没有数据");
}
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=='/';
}
//计算方法
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:
break;
}
return res;
}
}
