栈
栈的应用场景和介绍
- 栈的一个实际需求
- 请输入一个表达式
计算式：[7*2*2-5+1-5+3-3]
请问：计算机低沉是如何运算得到结果？注意不是简单的把算式列出运算，因为我们看这个算式 7*2*2-5，但是计算机怎么理解这个算式的(对计算机而言，它接受到的就是一个字符串)，我们讨论的这个问题。=》栈
- 请输入一个表达式
栈的介绍
- 栈的英文(stack)
- 栈是一个先进后出的(filo first in last out)的有序列表
- 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，成为栈底(Bottom).
- 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素更好相反，最后放入的元素最先删除，最先放入的元素最后删除。(子弹壳)
- 出栈(pop)和入栈(push)的概念如图所示
栈的应用场景
- 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
- 处理递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数，区域变量等数据存入堆栈中。
- 表达式的转换【中缀表达式转后缀表达式】与求值(实际解决)。
- 二叉树的遍历。
- 图形的深度优先(depth-first)搜索法。
栈的快速入门
- 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存储栈的数据内容。
- 实现思路分析，并画出示意图
代码
//定义一个类表示栈结构
class ArrayStack {
private int maxSize;//栈的大小
private int[] stack;//数组,数组模拟栈,数据就放在该数组
private int top = -1;//top表示栈顶,初始化为-1
//构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[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;
}
//出栈 pop,将栈顶的数据返回
public int pop() {
//先判断是否为空
if (isEmpty()) {
throw new RuntimeException("栈空");
}
return stack[top--];
}
//显示栈的情况【遍历栈】需要从栈顶往下开始遍历
public void show() {
if (isEmpty()) {
System.out.println("栈空,没有数据");
return;
}
for (int i = top; i >= 0; i--) {
System.out.print(stack[i] + " ");
}
System.out.println();
}
}
- 作业：使用链表来模拟栈
栈实现综合计算器(中缀表达式)
- 使用栈来实现综合计算器-自定义优先级[priority]
代码
public class Calculator {
public static void main(String[] args) {
//根据思路完成表达式的运算
String expresion = "7+2*6-4";
//创建两个栈，数栈，符号栈
ArrayStack numStack = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(10);
//定义相关变量
int index = 0;//用于扫描
int num1 = 0;
int num2 = 0;
int oper = 0;//符号
int result = 0;//结果
char ch = ' ';//将每次扫描到 char保存
//开始 while循环的扫描 expression
while (true) {
//依次得到 expression的每一个字符
ch = expresion.substring(index, index + 1).charAt(0);
//判断 ch是什么，然后得到相应的结果
if (operStack.isOperate(ch)) {//如果是运算符
//判断当前的符号栈是否为空
if (!operStack.isEmpty()) {
//如果符号栈有操作符
// 就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数
//在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
if (operStack.priority(ch) <= operStack.priority(operStack.getTop())) {
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
result = numStack.cal(num1, num2, oper);
//把运算的结果如数栈
numStack.push(result);
//然后将当前的操作符入符号栈
operStack.push(ch);
} else {
//如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
operStack.push(ch);
}
} else {
//如果为空直接入符号栈。。。
operStack.push(ch);// 1 + 3
}
} else {//如果是数,则直接放入栈
//? "1+3" '1' => 1
//把字符变成数字
//这里有问题！！！
numStack.push(ch - 48);
}
//让 index+1,并判断是否扫描到 expression最后
index++;
if (index >= expresion.length()) {
break;
}
}
//当表达式扫描完毕，就顺序的从 数栈和符号栈中 pop出相应的数和符号，并运行
while (!operStack.isEmpty()) {
//如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
result = numStack.cal(num1, num2, oper);
numStack.push(result);//把结果入栈
}
//将数栈的最后数，pop出，就是结果
System.out.println("表达式结果:" + expresion + "=" + numStack.pop());
}
}
//定义一个类表示栈结构
class ArrayStack {
private final int maxSize;//栈的大小
private final int[] stack;//数组,数组模拟栈,数据就放在该数组
private int top = -1;//top表示栈顶,初始化为-1
//构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[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;
}
//出栈 pop,将栈顶的数据返回
public int pop() {
//先判断是否为空
if (isEmpty()) {
throw new RuntimeException("栈空");
}
return stack[top--];
}
//显示栈的情况【遍历栈】需要从栈顶往下开始遍历
public void show() {
if (isEmpty()) {
System.out.println("栈空,没有数据");
return;
}
for (int i = top; i >= 0; i--) {
System.out.print(stack[i] + " ");
}
System.out.println();
}
//返回运算符的优先级,优先级是程序员来定的,优先级使用数字表示
//数字越大,则优先级越高
public int priority(int operate) {
if (operate == '*' || operate == '/') {
return 1;
} else if (operate == '+' || operate == '-') {
return 0;
} else {
//假定目前的表达式只有 + - * /
return -1;
}
}
//是不是运算符
public boolean isOperate(char val) {
return val == '+' || val == '-'
|| val == '*' || val == '/';
}
//计算结果
public int cal(int num1, int num2, int operate) {
int result = 0;//用于存放计算的结果
switch (operate) {
case '+':
result = num1 + num2;
break;
case '-':
result = num2 - num1;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num2 / num1;
break;
default:
break;
}
return result;
}
//返回当前栈顶
public int getTop() {
return top > -1 ? stack[top] : -1;
}
}
- 问题：
只能个位数计算，如果多位数计算可能出现结果错误。
代码完善
public class Calculator {
public static void main(String[] args) {
//根据思路完成表达式的运算
String expresion = "10+2*6-0";
//创建两个栈，数栈，符号栈
ArrayStack numStack = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(10);
//定义相关变量
int index = 0;//用于扫描
int num1 = 0;
int num2 = 0;
int oper = 0;//符号
int result = 0;//结果
char ch = ' ';//将每次扫描到 char保存
StringBuilder keepNum = new StringBuilder();//用于拼接的多位数的
//开始 while循环的扫描 expression
while (true) {
//依次得到 expression的每一个字符
ch = expresion.substring(index, index + 1).charAt(0);
//判断 ch是什么，然后得到相应的结果
if (operStack.isOperate(ch)) {//如果是运算符
//判断当前的符号栈是否为空
if (!operStack.isEmpty()) {
//如果符号栈有操作符
// 就进行比较，如果当前的操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop出两个数
//在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
if (operStack.priority(ch) <= operStack.priority(operStack.getTop())) {
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
result = numStack.cal(num1, num2, oper);
//把运算的结果如数栈
numStack.push(result);
//然后将当前的操作符入符号栈
operStack.push(ch);
} else {
//如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
operStack.push(ch);
}
} else {
//如果为空直接入符号栈。。。
operStack.push(ch);// 1 + 3
}
} else {//如果是数,则直接放入栈
/*
* 这里有问题！！！
* 1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
* 2. 在处理数，需要向 expression的表达式的 index 后再看以为，
* ===》如果是数就进行扫描，如果是符号才入栈
* 3. 因此我们需要定义一个变量 字符串，用于拼接
*
* */
keepNum.append(ch);
//如果 ch已经是 expression的最后以为，就直接入栈
if (index == expresion.length() - 1) {
numStack.push(Integer.parseInt(keepNum.toString()));
} else {
//判断下一个字符是不是数组，如果是数字，就继续进行扫描，如果是运算符，则入栈
//注意看后一位，不是 index++
if (operStack.isOperate(expresion.substring(index + 1, index + 2).charAt(0))) {
//如果后一位是运算符，则入栈: keepNum="1" or "123"
numStack.push(Integer.parseInt(keepNum.toString()));
//最最最重要的一步清空 keepNum
keepNum = new StringBuilder();
}
}
}
//让 index+1,并判断是否扫描到 expression最后
index++;
if (index >= expresion.length()) {
break;
}
}
//当表达式扫描完毕，就顺序的从 数栈和符号栈中 pop出相应的数和符号，并运行
while (!operStack.isEmpty()) {
//如果符号栈为空，则计算到最后的结果，数栈中只有一个数字【结果】
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
result = numStack.cal(num1, num2, oper);
numStack.push(result);//把结果入栈
}
//将数栈的最后数，pop出，就是结果
System.out.println("表达式结果:" + expresion + "=" + numStack.pop());
}
}
//定义一个类表示栈结构
class ArrayStack {
private final int maxSize;//栈的大小
private final int[] stack;//数组,数组模拟栈,数据就放在该数组
private int top = -1;//top表示栈顶,初始化为-1
//构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[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;
}
//出栈 pop,将栈顶的数据返回
public int pop() {
//先判断是否为空
if (isEmpty()) {
throw new RuntimeException("栈空");
}
return stack[top--];
}
//显示栈的情况【遍历栈】需要从栈顶往下开始遍历
public void show() {
if (isEmpty()) {
System.out.println("栈空,没有数据");
return;
}
for (int i = top; i >= 0; i--) {
System.out.print(stack[i] + " ");
}
System.out.println();
}
//返回运算符的优先级,优先级是程序员来定的,优先级使用数字表示
//数字越大,则优先级越高
public int priority(int operate) {
if (operate == '*' || operate == '/') {
return 1;
} else if (operate == '+' || operate == '-') {
return 0;
} else {
//假定目前的表达式只有 + - * /
return -1;
}
}
//是不是运算符
public boolean isOperate(char val) {
return val == '+' || val == '-'
|| val == '*' || val == '/';
}
//计算结果
public int cal(int num1, int num2, int operate) {
int result = 0;//用于存放计算的结果
switch (operate) {
case '+':
result = num1 + num2;
break;
case '-':
result = num2 - num1;
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num2 / num1;
break;
default:
break;
}
return result;
}
//返回当前栈顶
public int getTop() {
return top > -1 ? stack[top] : -1;
}
}
- 课后练习：给表达式加入小括号
前缀,中缀,后缀表达式(逆波兰表达式)
-
前缀表达式(波兰表达式)
- 前缀表达式又称波兰表达式，前缀表达式的运算符位于操作数之前。
- 举例：(3+4)x5-6 对应的前缀表达式就是：- x + 3 4 5 6
前缀表达式的计算机求值
从右到左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，
用运算符对它们做相应的计算(栈顶元素和次顶元素)，并将结果入栈；重复上述过程直到
表达式最左端，最后运算得出的值即为表达式的结果。
例如：(3+4)x5-6 对应的前缀表达式就是：- x + 3 4 5 6- 从右到左扫描，将6，5，4，3 压入堆栈。
- 遇到+运算符，因此弹出 3和4 (3为栈顶元素,4为此顶元素)，计算出 3+4的值，得7，在将 7入栈。
- 加下来时 x运算符，因此弹出 7和5，计算 7x5=35，将 35入栈。
- 最后时 -运算符，计算 35-6的值，即29，由此得出最终结果
-
中缀表达式
- 中缀表达式就是最常见的运算表达式，如：(3+4)x5-6
- 中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)。
-
后缀表达式
- 后缀表达式又称为逆波兰表达式与前缀表达式相似，只是运算符位于操作数之后。
- 中举列说明：(3+4)x5-6 对应的后缀表达式就是：3 4 + 5 x 6 -
- 再比如
正常的表达式 逆波兰表达式 a+b a b + a+(b-c) a b c - + a+(b-c)*d a b c - d * + a+d*(b-c) a d b c - * + a=1+3 a 1 3 + = 后缀表达式的计算机求值
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，
用运算符对他们做相应的计算(次顶元素和栈顶元素)，并将结果入栈；重复上述过程直到
表达式最右端，最后运算的出的值即为表达式的结果。
列如：(3+4)x5-6 对应的表达式就是：3 4 + 5 x 6 - ，针对后缀表达式求值步骤如下：- 从左至右扫描，将 3 和 4压入堆栈。
- 遇到运算符，因此弹出4和3(4为栈顶元素，3为顶元素)，计算出 3+4 的值，得7，再将7入栈。
- 将5入栈。
- 接下来是 x运算符，因此弹出 5和7，计算出 7x5=35，将35入栈。
- 将6入栈。
- 最后是 -运算符，计算出 35-6的值，即 29，由此得出最终结果。
逆波兰计算器
- 输入一个逆波兰表达式，使用栈(stack)，计算其结果。
- 支持小括号和多位整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。
代码
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
/**
* @Author zhaokuii11@163.com
* @Date 2022-07-11 19:51
* @Description
*/
public class PolandNotation {
public static void main(String[] args) {
//先定义逆波兰表达式
//(3+4)x5-6 => 34+5*6-
String suffixExpression = "34+5*6-";
/*
* 思路
* 1. 先将 (3+4)x5-6 放到 arraylist中
* 2. 将 arraylist 传递给一个方法，遍历 arraylist 配合栈完成计算
* */
List<String> list = getListString(suffixExpression);
System.out.println(list);
System.out.println("计算的结果是:" + calculate(list));
}
//将一个逆波兰表达式，依次将数据和运算放到 arraylist中
public static List<String> getListString(String suffixExpression) {
String[] split = suffixExpression.split("");
ArrayList<String> list = new ArrayList<>(suffixExpression.length());
list.addAll(Arrays.asList(split));
return list;
}
/**
* 完成对逆波兰表达式的运算
* 1. 从左至右扫描，将 3 和 4压入堆栈。
* 2. 遇到运算符，因此弹出4和3(4为栈顶元素，3为顶元素)，计算出 3+4 的值，得7，再将7入栈。
* 3. 将5入栈。
* 4. 接下来是 x运算符，因此弹出 5和7，计算出 7x5=35，将35入栈。
* 5. 将6入栈。
* 6. 最后是 -运算符，计算出 35-6的值，即 29，由此得出最终结果。
*
* @param list
* @return
*/
public static int calculate(List<String> list) {
//创建栈，只需要一个栈即可
Stack<String> stack = new Stack<>();
//遍历 list
list.forEach(s -> {
//使用正则
if (s.matches("\\d+")) {//匹配的是多位数
//入栈
stack.push(s);
} else {
//pop出两个数，并运算，在入栈
int num2 = Integer.parseInt(stack.pop());
int num1 = Integer.parseInt(stack.pop());
int result = operate(num1, num2, s);
//把 result入栈
stack.push(result + "");
}
});
//最后留在 stack中的数据是运算结果
return Integer.parseInt(stack.pop());
}
//运算
private static int operate(int num1, int num2, String s) {
int result = 0;
if ("+".equals(s)) {
result = num1 + num2;
} else if ("-".equals(s)) {
result = num1 - num2;
} else if ("*".equals(s)) {
result = num1 * num2;
} else if ("/".equals(s)) {
result = num1 / num2;
} else {
throw new RuntimeException("运算符错误!");
}
return result;
}
}
中缀表达式转为后缀表达式
- 初始化两个栈：预算符栈 s1和存储中间结果的栈 s2。
- 从左到右扫描中缀表达式。
- 遇到操作数时，将其压 s2。
- 遇到运算符时，比较其与 s1栈顶运算符的优先级。
- 如果 s1为空，或栈顶运算符为做括号 “(”，则直接将此运算符入栈。
- 否则，若优先级比栈顶运算符的高，也将运算符压入 s1。
- 否则，将 s1栈顶的运算符弹出并压入到 s2中，再次转到(4-1)与 s1中新的栈顶运算符相比较。
