本文详细介绍了栈的概念、应用场景和快速入门，重点讲解了如何使用栈实现中缀表达式转后缀表达式，并通过实例展示了计算过程。此外，还涵盖了逆波兰计算器的实现，包括中缀表达式转换为后缀表达式的步骤和代码实现。
栈
栈的一个实际需求
请输入一个表达式
计算式:[722-5+1-5+3-3] 点击计算【如下图】
请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算,因为我们看这个算式 7 * 2 * 2 - 5, 但是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，我们讨论的是这个问题。-> 栈
栈的介绍
-
栈的英文为(stack)
-
栈是一个先入后出(FILO-First In Last Out)的有序列表。
-
栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
-
根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
-
图解方式说明出栈(pop)和入栈(push)的概念
栈的应用场景
-
子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
-
处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
-
表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
-
二叉树的遍历。
-
图形的深度优先(depth 一 first)搜索法。
栈的快速入门
-
用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来储存栈的数据内容，下面我们就用数组模拟栈的出栈，入栈等操作。
-
实现思路分析,并画出示意图
- 代码实现
public class ArrayStackDemo {
public static void main(String[] args) {
//测试一下ArrayStack 是否正确
//先创建一个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.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("程序退出~~~");
}
}
class ArrayStack {
private int maxSize;
private int top;
private int[] stack;
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
top = -1;
stack = new int[maxSize];
}
public boolean isEmpty() {
return top == -1;
}
public boolean isFull() {
return top == maxSize-1;
}
public void push(int value) {
if (isFull()) {
System.out.println("The stack is full");
return;
}
stack[++top] = value;
}
public int pop() {
if (isEmpty()) {
throw new RuntimeException("The stack is empty!");
}
return stack[top--];
}
public int peak() {
if (isEmpty()) {
throw new RuntimeException("The stack is empty!");
}
return stack[top-1];
}
public void list() {
if (isEmpty()) {
System.out.println("The stack is empty!");
}
for (int i = top; i >= 0; i--) {
System.out.printf("stack[%d] = %d\n", i, stack[i]);
}
}
}
-
关于栈的一个小练习
课堂练习，将老师写的程序改成使用链表来模拟栈
栈实现综合计算器(中缀表达式)
使用栈来实现综合计算器-
思路分析(图解)
代码实现
[1. 先实现一位数的运算， 2. 扩展到多位数的运算]
package com.atguigu.stack;
public class Calculator {
public static void main(String[] args) {
//根据前面老师思路，完成表达式的运算
String expression = "7*2*2-5+1-5+3-4"; // 15//如何处理多位数的问题？
//创建两个栈，数栈，一个符号栈
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 = ""; //用于拼接 多位数
//开始while循环的扫描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);
} else {
//如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
operStack.push(ch);
}
}else {
//如果为空直接入符号栈..
operStack.push(ch); // 1 + 3
}
} else { //如果是数，则直接入数栈
//numStack.push(ch - 48); //? "1+3" '1' => 1
//分析思路
//1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
//2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
//3. 因此我们需要定义一个变量 字符串，用于拼接
//处理多位数
keepNum += ch;
//如果ch已经是expression的最后一位，就直接入栈
if (index == expression.length() - 1) {
numStack.push(Integer.parseInt(keepNum));
}else{
//判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
//注意是看后一位，不是index++
if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) {
//如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
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);//入栈
}
//将数栈的最后数，pop出，就是结果
int res2 = numStack.pop();
System.out.printf("表达式 %s = %d", expression, res2);
}
}
//先创建一个栈,直接使用前面创建好
//定义一个 ArrayStack2 表示栈, 需要扩展功能
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];
}
//增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
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;
}
//出栈-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]);
}
}
//返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
//数字越大，则优先级就越高.
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; // res 用于存放计算的结果
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;
}
}
逆波兰计算器
我们完成一个逆波兰计算器，要求完成如下任务:
-
输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果
-
支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。
-
思路分析
例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:
1．从左至右扫描，将 3 和 4 压入堆栈；
2．遇到+运算符，因此弹出 4 和 3（4 为栈顶元素，3 为次顶元素），计算出 3+4 的值，得 7，再将 7 入栈；
3．将 5 入栈；
4．接下来是×运算符，因此弹出 5 和 7，计算出 7×5=35，将 35 入栈；
5．将 6 入栈；
6．最后是-运算符，计算出 35-6 的值，即 29，由此得出最终结果
- 代码完成
public class PolandNotation {
public static void main(String[] args) {
//先定义给逆波兰表达式
//(30+4)×5-6 => 30 4 + 5 × 6 - => 164
// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
//测试
//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
//String suffixExpression = "30 4 + 5 * 6 -";
String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
//思路
//1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算
List<String> list = getListString(suffixExpression);
int res = calculate(list);
System.out.println(res);
}
/**
* 将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
* @param suffixExpression
* @return
*/
public static List<String> getListString(String suffixExpression) {
String[] split = suffixExpression.split(" ");
List<String> list = new ArrayList<>();
for (String ele : split) {
list.add(ele);
}
return list;
}
/**
* 完成对逆波兰表达式的运算
* @param list
* @return
*/
public static int calculate(List<String> list) {
Stack<String> stack = new Stack<>();
for(String item : list) {
if (item.matches("\\d+")) {
stack.push(item);
} else {
int num1 = Integer.parseInt(stack.pop());
int num2 = Integer.parseInt(stack.pop());
int res = 0;
// 取出的是String不是char，用“”不用‘’
if (item.equals("+")) {
res = num1 + num2;
} else if (item.equals("-")){
res = num2 - num1;
} else if (item.equals("*")) {
res = num1 * num2;
} else if (item.equals("/")) {
res = num2 / num1;
}
stack.push(String.valueOf(res));
}
}
return Integer.parseInt(stack.pop());
}
}
中缀表达式转换为后缀表达式
大家看到，后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将 中缀表达式转成后缀表达式。
具体步骤如下:
-
初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；
-
从左至右扫描中缀表达式；
-
遇到操作数时，将其压 s2；
-
遇到运算符时，比较其与 s1 栈顶运算符的优先级：
- 如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
- 否则，若优先级比栈顶运算符的高，也将运算符压入 s1；
- 否则，将 s1 栈顶的运算符弹出并压入到 s2 中，再次转到(4-1)与 s1 中新的栈顶运算符相比较；
-
遇到括号时：
- 如果是左括号“(”，则直接压入 s1
- 如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃
-
重复步骤 2 至 5，直到表达式的最右边
-
将 s1 中剩余的运算符依次弹出并压入 s2
-
依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
举例说明:
将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下
因此结果为 :“1 2 3 + 4 × + 5 –”
代码实现中缀表达式转为后缀表达式
思路分析
代码实现
public class PolandNotation {
public static void main(String[] args) {
//先定义给逆波兰表达式
//(30+4)×5-6 => 30 4 + 5 × 6 - => 164
// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
//测试
//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
//String suffixExpression = "30 4 + 5 * 6 -";
//思路
//1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算
String expression = "1+((2+3)*4)-5";//注意表达式
List<String> infixExpressionList = toInfixExpressionList(expression);
System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
List<String> suffixExpreesionList = parseSuffixExpressionList(infixExpressionList);
System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–]
System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?
}
/**
* 将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
* @param suffixExpression
* @return
*/
public static List<String> getListString(String suffixExpression) {
String[] split = suffixExpression.split(" ");
List<String> list = new ArrayList<>();
for (String ele : split) {
list.add(ele);
}
return list;
}
/**
* 完成对逆波兰表达式的运算
* @param list
* @return
*/
public static int calculate(List<String> list) {
Stack<String> stack = new Stack<>();
for(String item : list) {
if (item.matches("\\d+")) {
stack.push(item);
} else {
int num1 = Integer.parseInt(stack.pop());
int num2 = Integer.parseInt(stack.pop());
int res = 0;
// 取出的是String不是char，用“”不用‘’
if (item.equals("+")) {
res = num1 + num2;
} else if (item.equals("-")){
res = num2 - num1;
} else if (item.equals("*")) {
res = num1 * num2;
} else if (item.equals("/")) {
res = num2 / num1;
}
stack.push(String.valueOf(res));
}
}
return Integer.parseInt(stack.pop());
}
/**
* 将中缀表达式转成对应的List
* @param s 中缀表达式字符串
* @return 返回一个转换完成的list
*/
public static List<String> toInfixExpressionList(String s) {
List<String> list = new ArrayList<>();
int index = 0;
String str = "";//对多位数的拼接
char c; //遍历取出的一位字符
do {
c = s.charAt(index);
// 如果c是一个运算符，直接加入
if (c < 48 || c > 57) {
list.add(""+c);//将char转换为字符串
index++;
} else {
// 如果是一个数值，考虑多位数
str = ""; //置空
while (index < s.length() && s.charAt(index) >= 48 && s.charAt(index) <= 57 ) {
str += s.charAt(index); //拼接
index++;
}
list.add(str);
}
} while (index < s.length());
return list;
}
/**
* 将中缀表达式转换为后缀表达式
* @param list 传入List类型的中缀表达式
* @return 返回List类型的后缀表达式
*/
public static List<String> parseSuffixExpressionList(List<String> list) {
Stack<String> stack = new Stack<>();
List<String> strings = new ArrayList<>();
for (String item : list) {
if (item.matches("\\d+")) {
strings.add(item);
} else if (item.equals("(")) {
stack.push(item);
} else if (item.equals(")")) {
// peak而不是pop
while (!stack.peek().equals("(")) {
// 将符号依次加到string
strings.add(stack.pop());
}
// 消除一个括号
stack.pop();
} else {
// item 为运算符，需要比较优先级了,不涉及任何计算，只是转化,使用peak而不是pop
// 遇到（） 返回的是0
if ( stack.size()!=0 && Operation.getValue(item) <= Operation.getValue(stack.peek())) {
strings.add(stack.pop());
}
//这个运算符依旧要压入栈
stack.push(item);
}
}
// 将stack中剩余运算符依次放入list
while (stack.size() != 0) {
strings.add(stack.pop());
}
// list顺序遍历即可
return strings;
}
}
/**
* 编写一个类 Operation 可以返回一个运算符 对应的优先级
*/
class Operation {
private static int ADD = 1;
private static int SUB = 1;
private static int MUL = 2;
private static 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("不存在该运算符" + operation);
break;
}
return result;
}
}
注意：peak和pop的使用。用于跟栈顶元素的比较等操作应用peak。
逆波兰计算器完整版
完整版的逆波兰计算器，功能包括
-
支持 + - * / ( )
-
多位数，支持小数,
-
兼容处理, 过滤任何空白字符，包括空格、制表符、换页符
说明：逆波兰计算器完整版考虑的因素较多，下面给出完整版代码供同学们学习，其基本思路和前面一样，也 是使用到：中缀表达式转后缀表达式。
扫一扫
5150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
