栈
1. 介绍
- 先入后出的有序列表
- 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。
允许插入和删除的一端为变化的一端,成为栈顶(Top),另一端为固定的一端,成为栈底(Bottom)
- 最先放入的元素在栈底,最后放入的在栈顶,而删除元素则相反,最后放入的元素最先删除,最先放入的元素最后删除
应用场景:
1.子程序的调用:在跳往子程序前,会先将下个指令的地址存到堆栈中,直到子程序执行完后再将地址取出,以回到原来的程序中。
2.处理递归调用:和子程序的调用类似,只是除了存储下一个指令的地址外,也将参数、区域变量等数据存入堆栈中。
3.表达式的转换[中缀表达式转后缀表达式]与求值
4.二叉树遍历
5.图形的深度优先(depth-first)搜索法
2. 思路分析和代码实现
1.使用数组来模拟栈
2.定义一个top来表示栈顶,初始化为-1
3.入栈的操作,当有数据加入到栈时,top++; stack[top] == data;
4.出栈的操作。int value = stack[top]; top–; return value;
代码实现:
/**
* 数组模拟栈
*
* @author GHC
* @date 2022/7/11 13:37
*/
public class A1ArrayStackDemo {
public static void main(String[] args) {
// 测试ArrayStack
ArrayStack stack = 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":
stack.list();
break;
case "push":
System.out.println("请输入一个数字:");
int value = scanner.nextInt();
stack.push(value);
break;
case "pop":
try{
int res = stack.pop();
System.out.println(res + "出栈");
}catch (Exception e){
System.out.println(e.getMessage());
}
break;
case "exit":
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出!");
}
}
/**
* 定义一个ArrayStack表示栈
*/
class ArrayStack {
/**
* 栈的大小
*/
private int maxSize;
/**
* 数组,数组模拟栈,数据就放在该数组
*/
private int[] stack;
/**
* 栈顶top,初始值-1
*/
private int top = -1;
/**
* 构造器
*
* @param maxSize
*/
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;
}
/**
* 入栈
*/
public void push(int value) {
// 判是否满
if (isFull()) {
System.out.println("栈满");
return;
}
top++;
stack[top] = value;
}
/**
* 出栈
*/
public int pop() {
// 判空
if (isEmpty()) {
throw new IllegalArgumentException("栈空,没有数据");
}
int value = stack[top];
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]);
}
}
}
练习:使用链表模拟栈
3. 栈实现综合计算器(中缀表达式)
例:输入[7x2x2-5+1+3-4] 计算结果
思路:
1.通过一个index值(索引),来遍历我们的表达式
2.如果我们发现是一个数字,就直接入数栈
3.如果扫描到的是一个符号,就分如下情况:
3.1 如果发现当前的符号栈为空,就直接入栈
3.2 如果不为空,就进行比较没如果当前的操作符号的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,再从符号栈中pop出一个符号,进行运算,将得到的结果,入数栈,然后将当前的操作符入符号栈**。如果当前的操作符号的优先级大于或者等于栈中的操作符**,就直接入符号栈
4.当表达式扫描完毕后,就顺序的从数栈和符号栈中pop出相应的数和符号,并运算
5.最后再数只有个数字,就是结果
代码实现 :
验证 3+2*6-2
public class A2Calculator {
public static void main(String[] args) {
String expression = "3+2*6-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
char ch = ' ';
// 用于拼接多位数
String keepNum = "";
// 开始循环扫描expression
while (true) {
// 依次得到expression的每个字符
ch = expression.substring(index, index + 1).charAt(0);
// 判断ch是什么,然后做相应处理
if (operStack.isOper(ch)) {
// 判断当前的符号栈是否为空
if (!operStack.isEmpty()) {
// 处理
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 {
// 如果是数,则直接入数栈
// 存的是ASCII码 -48
// numStack.push(ch - 48); 此时有问题,改进
// 1.当处理多位数时,不能发现是一个数就立即入栈,因为他可能是多位数
// 2.在处理数,需要向expression的表达式的index,后看一位,如果是数就进行扫描,如果是符号栈再入栈
// 3.因此,我们需要定义一个字符串变量,用于拼接
// 处理多位数
keepNum += ch;
// 如果ch已经是expression的最后一位,就直接入栈
if (index == expression.length() - 1) {
numStack.push(Integer.parseInt(keepNum));
// 判断下一位是不是数字,如果是数字则继续扫描,如果是符号,则入栈
} else if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
// 如果是最后一位运算符,入栈
numStack.push(Integer.parseInt(keepNum));
// 清空
keepNum = "";
}
}
// 让 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);
}
System.out.printf("表达式:%s = %d", expression, numStack.pop());
}
}
/**
* 定义一个ArrayStack表示栈
* 需要扩展功能
*/
class ArrayStack2 {
/**
* 栈的大小
*/
private int maxSize;
/**
* 数组,数组模拟栈,数据就放在该数组
*/
private int[] stack;
/**
* 栈顶top,初始值-1
*/
private int top = -1;
/**
* 构造器
*
* @param maxSize
*/
public ArrayStack2(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
/**
* 栈满
*/
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()) {
throw new IllegalArgumentException("栈空,没有数据");
}
int value = stack[top];
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;
}
/**
* 返回当前栈顶的值,不是pop
*/
public int peek() {
return stack[top];
}
}
练习:加入小括号
4. 前缀、中缀、后缀表达式
4.1 前缀
从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对他们做相应的计算(栈顶元素和次顶元素),并将结果入栈;
例:(3+4)x 5-6 前缀表达式:- x + 3 4 5 6
1.从右至左扫描,将6 5 4 3压入堆栈
2.遇到+,弹出3 4,计算出7,7入栈
3.接下来是 x ,弹出7,5 ,计算得35,入栈
4.运算 -,34 - 6 得 29
4.2 中缀
中缀表达式的求值是我们人最熟悉的,但是对计算机来说却不好操作(前面我们讲的案例就能看的这个问题),因此,在计算结果时,往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)
4.3 后缀(逆波兰表达式)
1.后缀表达式又称逆波兰表达式与前缀表达式相似,只是运算符位于操作数之后
2.中举例说明:(3+4)×5-6对应的后缀表达式就是3 4+5×6-
**计算器求值:**从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素和栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果
4.4 逆波兰计算器
/**
* 逆波兰实现计算器
*
* @author GHC
* @date 2022/7/19 15:06
*/
public class A3PolandNotation {
public static void main(String[] args) {
// 先定义逆波兰表达式
// (3+4)x5-6 => 3 4 + 5 x 6 -
String suffixExpression = "3 4 + 5 * 6 - ";
// 1. 先将suffixExpression放到ArrayList中
// 2. 将ArrayList,配合栈完成计算(遍历)
List<String> list = getListString(suffixExpression);
System.out.println(list);
int res = calculate(list);
System.out.println("计算的结果是=" + res);
}
/**
* 将逆波兰表达式,依次将数据和运算符放入到ArrayList中
*/
public static List<String> getListString(String suffixExpression) {
// 将suffixExpression分隔
String[] split = suffixExpression.split(" ");
List<String> list = new ArrayList<String>();
for (String ele : split) {
list.add(ele);
}
return list;
}
/**
* 完成逆波兰表达式的计算
* 从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素和栈顶元素),并将结果入栈;
* 重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果
*/
public static int calculate(List<String> ls) {
// 创建栈,只需要一个栈即可
Stack<String> stack = new Stack<>();
// 遍历ls
for (String item : ls) {
// 使用正则表达式取出数,匹配多位数
if (item.matches("\\d+")) {
// 入栈
stack.push(item);
} else {
// 弹出顶栈 次顶栈,运算再入栈
int num2 = Integer.parseInt(stack.pop());
int num1 = Integer.parseInt(stack.pop());
int res = 0;
if (item.equals("+")) {
res = num1 + num2;
} else if (item.equals("-")) {
res = num1 - num2;
} else if (item.equals("*")) {
res = num1 * num2;
} else if (item.equals("/")) {
res = num1 / num2;
} else {
throw new IllegalArgumentException("运算符有误!");
}
// res 入栈
stack.push(String.valueOf(res));
}
}
return Integer.parseInt(stack.pop());
}
}
4.5 中缀表达式转后缀表达式
1.初始化两个栈:运算符s1和存储中间结果的栈s2
2.从左至右扫描中缀表达式
3.遇到操作数,压入s2
4.遇到运算符时,比较其与s1栈顶运算符的优先级:
4.1 如果s1为空,或栈顶运算符为左括号(,则直接将此运算符入栈;
4.2 否则,若优先级比栈顶运算符的高,也将运算符压入s1;
4.3 否则,将s1栈顶的运算符弹出并压入s2,再次转到(4.1)与s1中新的栈顶运算符比较;
5.遇到括号时:
5.1 如果是左括号,直接压入s1;
5.2 如果是右括号,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃;
6.重复步骤2-5,直到表达式最右边
7.将s1中剩余的运算符依次弹出并压入s2
8.依次弹出s2中的元素并输出,结果的逆序即为中缀转后缀
例子
中缀:1+((2+3)x4-5) => 1 2 3 + 4 x + 5 -
/**
* 将中缀表达式转成对应的List
*/
public static List<String> toInfixExpressionList(String s) {
// 定义一个list,存放在中缀表达式对应的内容
List<String> ls = new ArrayList<>();
// 这是一个指针,用于遍历中缀表达式字符串
int i = 0;
// 对多位数拼接
StringBuilder str;
// 每遍历到一个字符就放入c
char c;
do {
// 如果c是一个非数字,我需要加入到ls
if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
ls.add("" + c);
// 指针后移
i++;
} else {
// 如果是一个数字,则需要拼接
// 先将str置空,'0'[48] -> '9'[57]
str = new StringBuilder();
while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
// 拼接
str.append(c);
i++;
}
ls.add(str.toString());
}
} while (i < s.length());
return ls;
}
/**
* 中缀表达式的List转后缀表达式的List
*/
public static List<String> parseSuffixExpressionToList(List<String> ls) {
// 定义两个栈
// 符号栈
Stack<String> s1 = new Stack<>();
// 存储中间结果,s2没有pop操作,因此用List代替
List<String> s2 = new ArrayList<>();
// 遍历ls
for (String item : ls) {
// 如果是一个数就入栈,加入s2
if (item.matches("\\d+")) {
s2.add(item);
// 如果是左括号,直接压入s1
} else if ("(".equals(item)) {
s1.push(item);
// 如果是右括号,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃
} else if (")".equals(item)) {
while (!"(".equals(s1.peek())) {
s2.add(s1.pop());
}
// 消除一对括号
s1.pop();
} else {
// 当s1栈顶的运算符的优先级小于等于栈顶运算符的优先级,将s1栈顶的运算符弹出并压入s2,再次转到(4.1)与s1中新的栈顶运算符比较
while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
s2.add(s1.pop());
}
// 将item压入s1
s1.push(item);
}
}
// 将s1中剩余的运算符依次弹出并压入s2
while (s1.size() != 0) {
s2.add(s1.pop());
}
return s2;
}
/**
* 判断运算符对应的优先级
*/
class Operation {
private static final int ADD = 1;
private static final int SUB = 1;
private static final int MUL = 2;
private static final int DIV = 2;
/**
* 返回对应优先级数字
*/
public static int getValue(String operation) {
int result = 0;
switch (operation) {
case "+":
result = ADD;
break;
case "-":
result = SUB;
break;
case "*":
result = MUL;
break;
case "/":
result = DIV;
break;
default:
System.out.println("不存在改运算符");
break;
}
return result;
}
}
结果
String expression = "1+((2+3)*4-5)";
List<String> toInfixExpressionList = toInfixExpressionList(expression);
System.out.println("中缀表达式" + toInfixExpressionList);
List<String> parseSuffixExpressionToList = parseSuffixExpressionToList(toInfixExpressionList);
System.out.println("后缀表达式:" + parseSuffixExpressionToList);
System.out.println("结果:" + calculate(parseSuffixExpressionToList));
中缀表达式[1, +, (, (, 2, +, 3, ), *, 4, -, 5, )]
后缀表达式:[1, 2, 3, +, 4, *, 5, -, +]
结果:16