栈( Stack )
1 栈的介绍
- 栈的英文为 Stack
- 栈是一个先入后出（FILO-First In Last Out）的有序列表
- 栈(stack)是限制线性元素表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一段，称为栈顶(Top)，另一端为固定的一段，称为栈底(Bottom)
- 根据栈的定义可知，最先放入栈中的元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
2 栈的应用场景
- 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中
- 处理递归调用：和子程序的调用类似，只是除了储存了下一个指令的地址外，也将参数、区域变量等数据存入堆栈中
- 表达式的转换与求值（实际解决）
- 二叉树的遍历
- 图形的深度优先（depth-first）搜索法
3 数组模拟栈
思路分析：
- 使用数组来模拟栈
- 定义一个top 来表示栈顶，初始化为 -1
- 入栈的操作，当有数据加入到栈时，
top++;stack[top] = data - 出栈的操作，
int value = stack[top];top--;return value
package com.crisp.Stack;
import java.util.Scanner;
public class ArrayStackDemo {
public static void main(String[] args) {
//测试栈
//创建一个菜单
ArrayStack stack = new ArrayStack(5);
String key = "";
boolean loop = true;//控制是否退出菜单
Scanner scanner = new Scanner(System.in);
while(loop){
System.out.println("show：显示栈");
System.out.println("push：添加数据到栈（入栈）");
System.out.println("pop：数据出栈（出栈）");
System.out.println("exit：退出程序");
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.printf("出栈的数据是：%d\n",res);
} catch (Exception e){
// TODO: handle exception
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;//模拟栈的数组，数据存放其中
private int top = -1;//top表示栈顶，初始化为-1
//构造器
public ArrayStack(){}
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;
}
//出栈-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]);
}
}
}
4 链表模拟栈
思路分析：
- 使用一个链表来模拟栈
- 创建一个top 节点，使其一直指向链表中的第一个元素
- 入栈时，新加入的节点连接在top 后面，
newNode.next = top.next;top.next = newNode - 出栈时，top 后面的节点先出，
top.next = top.next.next
package com.crisp.Stack;
import java.util.Scanner;
public class LinkedListStackDemo {
public static void main(String[] args) {
//测试，创建一个菜单
LinkdedListStack linkdedListStack = new LinkdedListStack(5);
String key = "";
boolean loop = true;//控制是否退出菜单
Scanner scanner = new Scanner(System.in);
while(loop){
System.out.println("show：显示栈");
System.out.println("push：添加数据到栈（入栈）");
System.out.println("pop：数据出栈（出栈）");
System.out.println("exit：退出程序");
System.out.println("请输入您要进行的操作：");
key = scanner.next();
switch (key){
case "show":
linkdedListStack.show();
break;
case "push":
System.out.println("请输入一个数：");
StackNode value = new StackNode(scanner.nextInt());
linkdedListStack.push(value);
break;
case "pop":
try {
int res = linkdedListStack.pop();
System.out.printf("出栈的数据是：%d\n",res);
} catch (Exception e){
// TODO: handle exception
System.out.println(e.getMessage());
}
break;
case "exit":
scanner.close();
loop =false;
break;
default:
break;
}
}
System.out.println("~~~程序已经退出~~~");
}
}
//定义一个LinkedListStack来表示栈结构
//用链表模拟栈
class LinkdedListStack{
//定义top节点，始终指向链表中第一个元素
//即栈的最后进入的元素
private StackNode top = new StackNode(-1);//将其初始化为-1
private int maxSize;//定义栈的最大容量
//构造器
public LinkdedListStack(int maxSize) {
this.maxSize = maxSize;
}
//判断链表是否空
public boolean isEmpty(){
if(top.getNext() == null){
return true;
}else{
return false;
}
}
//判断链表是否满
public boolean isFull(){
int i = 0;
//创建一个辅助节点用来遍历链表
StackNode temp = top;
while(true){
if(i == maxSize){
return true;
}
if(i < maxSize && temp.getNext() == null){
return false;
}
//后移
i++;
temp = temp.getNext();
}
}
//入栈
public void push(StackNode newNode){
//判满
if(isFull()){
System.out.println("~栈满！无法入栈~");
return;
}
//将新节点连接到top的下一个节点
newNode.setNext(top.getNext());
top.setNext(newNode);
}
//出栈
public int pop(){
//判空
if(isEmpty()){
//抛出异常处理
throw new RuntimeException("~栈空！没有可以出栈的元素~");
}
//用一个辅助变量存储要出栈的节点的值
int value = top.getNext().getNo();
//将与top相连接的节点出栈
top.setNext(top.getNext().getNext());
return value;
}
//遍历
public void show(){
//判空
if(isEmpty()){
System.out.println("~栈空！没有可以遍历的元素~");
return;
}
//既然是栈，就从top开始遍历
//创建一个辅助节点用来遍历链表
StackNode temp = top;
int i =0;
while(true) {
if(temp.getNext() == null){
return;
}
System.out.println(temp.getNext().getNo());
temp = temp.getNext();
}
}
}
//定义节点存储栈的数据
class StackNode{
private int no;
private StackNode next;//下一个节点
//构造器
public StackNode(int no) {
this.no = no;
}
//set方法
public int getNo() {
return no;
}
public StackNode getNext() {
return next;
}
//get方法
public void setNo(int no) {
this.no = no;
}
public void setNext(StackNode next) {
this.next = next;
}
}
5 使用栈完成表达式
思路：
- 通过一个index 值（索引），来遍历我们的表达式
- 如果我们发现是一个数字，就直接入数栈
- 如果发现扫描到的是一个符号，就分如下情况
- 如果发现当前符号栈为空，就直接入栈
- 如果符号栈有操作符，就进行比较，如果当前操作符的优先级小于或者等于栈中的操作符，就需要从数栈中pop 出两个数，再从符号栈中pop 出一个符号，进行运算，将得到结果，入数栈
- 如果当前操作符的优先级大于栈中的操作符，就直接入符号栈
- 当表达式扫描完毕，就顺序的从数栈和符号栈中pop 出相应的数和符号，并运行
- 最后再数栈只有一个数字时，就是表达式的结果
package com.crisp.Stack;
public class CalculatorDemo {
public static void main(String[] args) {
String expression = "100*2/4+3";
//用于拼接字符串
String Keepnum = "";
//创建两个栈，一个数栈，一个符号栈
CalStack numStack = new CalStack(10);
CalStack operStack = new CalStack(10);
//定义需要的相关变量
int index = 0;//用于扫描
int num1 = 0;
int num2 = 0;
int oper = 0;
int res = 0;
char ch = ' ';//将每次扫描得到char保存到ch
//开始扫描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 {
//如果是数，直接入栈
//注意ch中的值是字符，根据ASCII转换成相应的数
//1、当处理多位数时不能只将一位入栈
//2、需要在expression再向后看一位
//3、因此需要定义一个字符串变量，用于拼接
//处理多位数
Keepnum += ch;
//如果ch已经是最后一位，直接入栈
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 用过后需要初始化
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\n",expression,numStack.pop());
}
}
//创建一个表达式栈，继承数组栈的功能
class CalStack extends ArrayStack{
//构造器
public CalStack(int maxSize) {
super(maxSize);
}
//返回运算符的优先级
//优先级由程序员确定
//我们可以定义高优先级的运算符代表的数字更大
//java中int和char可以混用
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;//注意运算顺序
default:
break;
}
return res;
}
//增加一个方法，可以返回当前栈顶的值，但是不是pop
//即不弹出栈
public int peek(){
return getStack()[getTop()];
}
}
6 前缀、中缀、后缀表达式(逆波兰表达式)
6.1 前缀表达式(波兰表达式)
- 前缀表达式又称波兰表达式，前缀表达式的运算符位于操作数之前
- 举例：
(3+4)*5-6对应的前缀表达式就是- * + 3 4 5 6
前缀表达式的计算机求值
- 从右至左扫描，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们做相应的计算(栈顶元素和次顶元素)，并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
- 例如：
(3+4)*5-6对应的前缀表达式就是- * + 3 4 5 6，步骤如下：- 从右至左扫描，将6、5、4、3压入栈堆
- 遇到
+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈 - 接下来是
*运算符，因此弹出7和5，计算出7*5 = 35，将35入栈 - 最后是
-运算符，计算出35-6的值，即29，由此得出最终结果
6.2 中缀表达式
- 中缀表达式就是常见的运算表达式，如：
(3+4)*5-6 - 中缀表达式的求值是我们人最熟悉的，但是对计算机不好操作，因为要判断操作符的优先级问题。因此，在计算结果时，往往会将中缀表达式转成其他表达式来操作（一般转为后缀表达式）
6.3 后缀表达式(逆波兰表达式)
- 后缀表达式又称逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后
- 比如：
(3+4)*5-6对应的后缀表达式就是3 4 + 5 * 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)*5-6对应的后缀表达式就是3 4 + 5 * 6 -，步骤如下：- 从左至右扫描，将3和4压入栈堆
- 遇到
+操作符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算3+4的值，得7，再将7入栈 - 将5入栈
- 接下来是
*运算符，因此弹出5和7，计算出7*5 = 35，将35入栈 - 将6入栈
- 最后是
-运算符，计算出35-6的值，即29，由此得出最终结果
6.4 逆波兰计算器
我们完成一个逆波兰计算器，要求完成如下任务：
- 输入一个逆波兰表达式，使用栈（Stack），计算其结果
- 支持小括号和多位数整数
- 思路分析
- 代码完成
package com.crisp.Stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class RePolishNotation {
public static void main(String[] args) {
//先定义逆波兰表达式
//(3+4)*5-6 => 3 4 + 5 * 6 -
//为了方便，将逆波兰表达式的每个操作位用空格隔开
String suffixExpression = "3 4 + 5 * 6 -";
//思路
//1、将后缀表达式放入ArrayList中
//2、将ArrayList传递给一个方法，遍历ArrayList配合栈完成计算
List<String> rpnList = getListString(suffixExpression);
System.out.println("rpnList = "+rpnList);
int res = calculator(rpnList);
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 calculator(List<String> ls){
//创建堆栈，只需要一个即可
Stack<String> stack = new Stack<String>();
//遍历ls
for(String item: ls){
//使用正则表达式来取出数
if(item.matches("\\d+")){
//匹配的是多位数
//入栈
stack.push(item);
}else{
//pop出两个数并运算，再入栈
//注意：字符串转为整型
int num2 = Integer.parseInt(stack.pop());
int num1 = Integer.parseInt(stack.pop());
int res = 0;
switch (item){
case "+":
res = num1 + num2;
break;
case "-":
res = num1 - num2;
break;
case "*":
res = num1 * num2;
break;
case "/":
res = num1 / num2;
break;
default:
throw new RuntimeException("运算符有误！！！");
}
//把res入栈
//将整型转为字符串的简单操作
stack.push(res + "");
}
}
//最后留在stack中的数据就是运算结果
//注意将符号转为整型
return Integer.parseInt(stack.pop());
}
}
6.6.5 中缀表达式转换位后缀表达式
在前面代码实现的过程中，我们发现后缀表达式适合计算机进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将中缀表达式转成后缀表达式
具体步骤如下：
- 初始化两个栈：运算符栈s1 和储存中间结果的栈s2
- 从左至右扫描中缀表达式
- 遇到操作数，将其压入s2
- 遇到运算符时，比较其与s1 栈顶运算符的优先级
- 如果s1 为空，或栈顶运算符位左括号
(，则直接将此运算符入栈 - 若优先级比栈顶运算符的高，也将运算符压入s1
- 否则，将s1 栈顶的运算符弹出并压入到s2 中，再次转换(4-1)与s1中新的栈顶运算符相比较
- 如果s1 为空，或栈顶运算符位左括号
- 遇到括号时：
- 如果是左括号
(，则直接压入s1 - 如果是右括号
)，则依次弹出s1 栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
- 如果是左括号
- 重复执行2至5步，直到表达式的最右边
- 将s1 中剩余的运算符依次弹出并压入s2
- 一次弹出s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
代码演示：
package com.crisp.Stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Stack;
public class RePolishNotation {
public static void main(String[] args) {
//测试完整功能
String expression = "1+((2+3)*4)-5";
System.out.printf("%s 对应的后缀表达式为：",expression);
System.out.println(Infix2Suffix(expression));
System.out.printf("%s = %d\n",expression,calculator(Infix2Suffix(expression)));
}
//实现中缀转后缀功能
public static List<String> Infix2Suffix(String infixexpression){
//定义一个InList存放中缀表达式的内容
List<String> InList = new ArrayList<String>();
int index = 0;//用于扫描
char ch = ' ';//将每次扫描得到char保存到ch
String str;//对多位数拼接
//一、将infixexpression中的值存入InList中
do{
//如果ch是一个非数字
if((ch=infixexpression.charAt(index)) < 48 || (ch=infixexpression.charAt(index)) > 57){
InList.add("" + ch);
index++;//index后移
}else { //如果是一个数字，需要考虑多位数
str = "";//将str置为空
while(index < infixexpression.length() && (ch=infixexpression.charAt(index)) >= 48 && (ch=infixexpression.charAt(index)) <= 57){
str += ch;//拼接多位数
index++;
}
InList.add(str);
}
}while (index < infixexpression.length());
//二、将InList中的值转为后缀表达式
//初始化两个栈，运算符栈s1，存储中间结果的栈s2
Stack<String> s1 = new Stack<String>();
//说明：由于s2栈中元素不参与pop操作，且最后返回值为逆序，所以用List代替
List<String> s2 = new ArrayList<String>();
//遍历InList
for(String item: InList){
//用正则表达式判断
if(item.matches("\\d+")){
//如果是一个数，直接加入s2
s2.add(item);
}else if(item.equals("(")){
//如果是左括号，直接压入s1
s1.push(item);
}else if(item.equals(")")){
//如果是右括号`)`，则依次弹出s1 栈顶的运算符，并压入s2
//直到遇到左括号为止，此时将这一对括号丢弃
while(!s1.peek().equals("(")){
s2.add(s1.pop());
}
s1.pop();//将（弹出s1，消除小括号
}else{
//当item的优先级小于等于栈顶元素优先级
//将s1栈顶的运算符弹出并加入到s2中
//再次与s1中新的栈顶运算符比较
while(s1.size() != 0 && priority(s1.peek()) >= priority(item)){
s2.add(s1.pop());
}
//还需要将item入栈
s1.push(item);
}
}
//将s1中剩余的运算符依次弹出并加入s2
while(s1.size() != 0){
s2.add(s1.pop());
}
//由于存放在List，因此按顺序输出就是对应的后缀表达式
return s2;
}
//创建一个方法，返回运算符的优先级
public static int priority(String oper){
if(Objects.equals(oper, "*") || Objects.equals(oper, "/")){
return 2;
}else if(Objects.equals(oper, "+") || Objects.equals(oper, "-")){
return 1;
}else{
return -1;//假定目前表达式只含有+，-，*，/
}
}
//完成对逆波兰表达式的运算
public static int calculator(List<String> ls){
//创建堆栈，只需要一个即可
Stack<String> stack = new Stack<String>();
//遍历ls
for(String item: ls){
//使用正则表达式来取出数
if(item.matches("\\d+")){
//匹配的是多位数
//入栈
stack.push(item);
}else{
//pop出两个数并运算，再入栈
//注意：字符串转为整型
int num2 = Integer.parseInt(stack.pop());
int num1 = Integer.parseInt(stack.pop());
int res = 0;
switch (item){
case "+":
res = num1 + num2;
break;
case "-":
res = num1 - num2;
break;
case "*":
res = num1 * num2;
break;
case "/":
res = num1 / num2;
break;
default:
throw new RuntimeException("运算符有误！！！");
}
//把res入栈
//将整型转为字符串的简单操作
stack.push(res + "");
}
}
//最后留在stack中的数据就是运算结果
//注意将符号转为整型
return Integer.parseInt(stack.pop());
}
}
该笔记整理自B站
BV1E4411H73v，博主稍加整理改进以及排版
扫一扫
3489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
