栈
栈的实际需求
请输入一个表达式：722-5+1-5+3+3
请问：
计算机底层是如何运算得到结果的？注意不是简单的把算式列出运算，因为我们看到的这个7 * 2 * 2 - 5，但是计算机怎么理解这个算式的（对于计算机而言，它接收到的就是一个字符串）,我们讨论的是这个问题–>>栈
栈的介绍
1.栈的英文（stack）
2.栈是一个先入后出的有序列表
3.栈是限制线性表中元素的插入和删除只能在线性表的同一段进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top），另一端为固定的一段，称为栈底（Bottom）。
4.根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
5.出栈和入栈的概念
栈的应用场景
- 子程序的调用：在跳往子程序前，会先将下一个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中
- 处理递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数，区域变量等数据存入堆栈中
- 表达式的转换[中缀表达式转后缀表达式]与求值（实际解决）
- 二叉树的遍历
- 图形的深度优化（depth-first）搜索法
栈的快速入门
1.用数组模拟栈的使用，由于栈 是一种有序列表，可以使用数组的结构来存储栈的数据内容
思路分析：
1.使用数组来模拟栈
2.定义一个top表示栈顶，初始值为-1
3.入栈的操作，当有数据加入到栈时：top++；stack[top]=data;
4.出栈操作：int value=stack[top]; top-- ; return value;
代码实现(数组):
public class ArrayStack {
private int maxSize; //栈的大小
private int top = -1; //top表示栈顶，初始值为-1
private int[] stack; //数组，数组模拟栈，数据就放在该数组
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 data) {
if (isFull()) {
//如果栈满则不能入栈
System.out.println("栈满");
return;
}
stack[++top] = data;
}
//出栈
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.println(stack[i]);
}
}
}
代码实现(链表):
栈实现综合计算器
思路分析：
1.通过一个index（索引值），来遍历我们的表达式
2.如果发现是一个数字，就直接加入数栈
3.如果发现是一个符号，就分下面情况
3.1如果当前的符号栈为空，就直接入栈
3.2如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或等于栈中的操作符，就需要从数栈中pop两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，然后当前的操作符入符号栈
3.3如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出响应的数和符号，并运行
5.最后在数栈只有一个数字，就是表达式的结果
代码实现：
栈类：
package com.栈;
public class ArrayStack {
private int maxSize; //栈的大小
private int top = -1; //top表示栈顶，初始值为-1
private int[] stack; //数组，数组模拟栈，数据就放在该数组
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 data) {
if (isFull()) {
//如果栈满则不能入栈
System.out.println("栈满");
return;
}
stack[++top] = data;
}
//出栈
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.println(stack[i]);
}
}
//返回栈顶
public int peek() {
return stack[top];
}
//返回运算符的优先级，使用数字表示
//数字越大，则优先级越高
public int priority(char 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, char 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;
}
return res;
}
}
进行运算
package com.栈;
public class Calculator {
public static void main(String[] args) {
String expression = "3+2*6-9-9";
ArrayStack numStack = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(10);
char[] chars = expression.toCharArray();
int num1 = 0;
int num2 = 0;
int res = 0;
char oper = 0;
for (int i = 0; i < chars.length; i++) {
//判断char[i]是什么
if (operStack.isOper(chars[i])) {//如果是运算符
//判断当前符号栈是否为空
if (operStack.isEmpty()) {
//为空，直接入栈
operStack.push(chars[i]);
} else {
//如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或等于栈中的操作符,
// 就需要从数栈中pop两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，
// 然后当前的操作符入符号栈
if (operStack.priority(chars[i]) <= operStack.priority((char) operStack.peek())) {
num1 = numStack.pop();
num2 = numStack.pop();
oper = (char) operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);
operStack.push(chars[i]);
} else {
//如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
operStack.push(chars[i]);
}
}
} else {
//如果发现是一个数字，就直接加入数栈
numStack.push(chars[i] - 48);
}
}
while (true) {
if (operStack.isEmpty()) {
//如果符号栈为空，则计算到最后
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = (char) operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);
}
System.out.println(numStack.pop());
}
}
上面代码bug
1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
2.在处理数，需要向expression的表达式的index后再看一位，如果是数就进行扫描，如果是符号才入栈
3.因此我们需要定义变量，用于拼接
package com.栈;
public class Calculator {
public static void main(String[] args) {
String expression = "300+2*6-9";
ArrayStack numStack = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(10);
char[] chars = expression.toCharArray();
int num1 = 0;
int num2 = 0;
int res = 0;
char oper = 0;
String str="";
for (int i = 0; i < chars.length; i++) {
//判断char[i]是什么
if (operStack.isOper(chars[i])) {//如果是运算符
//判断当前符号栈是否为空
if (operStack.isEmpty()) {
//为空，直接入栈
operStack.push(chars[i]);
} else {
//如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或等于栈中的操作符,
// 就需要从数栈中pop两个数，再从符号栈中pop出一个符号，进行运算，将得到的结果入数栈，
// 然后当前的操作符入符号栈
if (operStack.priority(chars[i]) <= operStack.priority((char) operStack.peek())) {
num1 = numStack.pop();
num2 = numStack.pop();
oper = (char) operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);
operStack.push(chars[i]);
} else {
//如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
operStack.push(chars[i]);
}
}
} else {
//如果发现是一个数字，就直接加入数栈
//1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
//2.在处理数，需要向expression的表达式的index后再看一位，如果是数就进行扫描，如果是符号才入栈
//3.因此我们需要定义变量字符串，用于拼接
str += chars[i];
//如果chars[i]是最后一位，就直接入栈
if (i == chars.length - 1) {
numStack.push(Integer.parseInt(str));
}else {
if (operStack.isOper(chars[i + 1])) {
//如果后一位是运算符，则入栈
numStack.push(Integer.parseInt(str));
//重要！！！,str要清空
str = "";
}
}
}
}
while (true) {
if (operStack.isEmpty()) {
//如果符号栈为空，则计算到最后
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = (char) operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);
}
System.out.println(numStack.pop());
}
}
给表达式加入小括号
前缀，中缀，后缀表达式（逆波兰表达式）
前缀表达式（波兰表达式）
1.前缀表达式又称为波兰式，前缀表达式的运算位于操作数之前
2.举例说明：(3+4)*5-6 对应的前缀表达式就是: - * + 3 4 5 6
前缀表达式的计算机求值
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算**(栈顶元素 和 次顶元素)**，并将结果入栈，重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
例如:
(3+4)X5-6 对应的前缀表达式就是 - *+3456,针对前表达式求值如下!
1.从右至左扫描，将6、5、4、3压入堆栈
2.遇到+运算符，因此弹出3和4(3为栈顶元素，4为次顶元素) ，计算出3+4的值，得7.再将7入栈
3.接下来是X运算符，因此弹出7和5，计算出7X5=35，将35入栈
4.最后是-运算符，计算出35-6的值，即29，由此得出最终结果
中缀表达式
1.中缀表达式就是常见的运算表达式，如(3+4)*5-6
2.中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作（前面我们讲的案例就能看到这个问题），因此，在计算结果时，往往会将中缀表达式转成其他表达式来操作（一般转成后缀表达式）
后缀表达式
1.后缀表达式又称逆波兰表达式与前缀表达式相似，只是运算符位于操作数之后
2.举例说明： (3+4)*5-6对应的后缀表达式就是3 4 5 * 6 -
3.再比如：
| 正常表达式 | 逆波兰表达式 |
|---|---|
| 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，由此得出最终结果
逆波兰计算器
我们完成一个逆波兰计算器，要求完成如下任务：
- 输入一个逆波兰表达式，使用栈，计算其结果
- 支持小括号和多位数整数，因为我们主要讲的时数据结构，因此计算器进行简化，只支持对整数的计算
思路分析
看上面的后缀表达式的计算机求值
代码实现
package com.栈;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static void main(String[] args) {
String suffixExpression = "30 4 + 5 * 6 -";
List<String> listString = getListString(suffixExpression);
System.out.println(listString);
int calculate = calculate(listString);
System.out.println(calculate);
}
//将逆波兰表达式，依次将数据和运算符放入到ArrayList中
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;
}
public static int calculate(List<String> ls) {
//创建一个栈即可
Stack<String> stack = new Stack<>();
//遍历
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;
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 RuntimeException("运算符有误");
}
stack.push(res + "");
}
}
return Integer.parseInt(stack.pop());
}
}
中缀表达式转后缀表达式
大家看到，后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将 中缀表达式转成后缀表达式
具体步骤如下:
1.初始化两个栈:运算符栈s1和储存中间结果的栈s2;
2.从左至右扫描中缀表达式;
3.遇到操作数时，将其压s2;
4.遇到运算符时，比较其与s1栈顶运算符的优先级:
- 如果s1为空，或栈顶运算符为左括号“（”，则直接将此运算符入栈:
- 否则，若优先级比栈顶运算符的高，也将运算符压入s1;
- 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较:
5.遇到括号时:
- 如果是左括号“(”,则直接压入s1
- 如果是右括号“”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为
止，此时将这一对括号丢弃
6.重复步骤2至5，直到表达式的最右边
7.将s1中剩余的运算符依次弹出并压入s2
8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
举例说明
将“1+((2+3)*4)-5”转换为后缀表达式的过程如下：
代码实现
package com.栈;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static void main(String[] args) {
String expression = "1+((2+3)*4)-5";
List<String> list = toInfixExpressionList(expression);
System.out.println(list);
List<String> list1 = parseSuffixExpressionList(list);
System.out.println(list1);
System.out.println(calculate(list1));
}
//将逆波兰表达式，依次将数据和运算符放入到ArrayList中
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;
}
public static int calculate(List<String> ls) {
//创建一个栈即可
Stack<String> stack = new Stack<>();
//遍历
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;
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 RuntimeException("运算符有误");
}
stack.push(res + "");
}
}
return Integer.parseInt(stack.pop());
}
//方法：将中缀表达式转成对应的List
public static List<String> toInfixExpressionList(String s) {
List<String> ls = new ArrayList<>();
String str = "";
char[] chars = s.toCharArray();
for (int i = 0; i < chars.length; i++) {
//如果c是一个非数字，我们就直接加入到ls
if (chars[i] < 48 || chars[i] > 57) {
ls.add(chars[i] + "");
} else {
//如果是数字，就要考虑多位数
str += chars[i];
if (i == chars.length - 1) {
ls.add(str);
str = "";
} else if (chars[i + 1] < 48 || chars[i + 1] > 57) {
ls.add(str);
str = "";
}
}
}
return ls;
}
//将得到的中缀表达式对应的List==>后缀表达式对应的List
public static List<String> parseSuffixExpressionList(List<String> ls) {
//定义两个栈
Stack<String> s1 = new Stack<>();
//说明：因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
//因此比较麻烦，这里我们就不用Stack<String>直接使用List<String> s2
List<String> s2 = new ArrayList<>();//存储中间结果的
for (String item : ls) {
//如果是数，将其加入s2
if (item.matches("\\d+")) {
s2.add(item);
} else if (item.equals("(")) {
s1.push(item);
} else if (item.equals(")")) {
while (!s1.peek().equals("(")) {
s2.add(s1.pop());
}
s1.pop();//!!!将（ 弹出s1
}else {
//遇到运算符时
while (s1.size() != 0) {
if ( s1.peek().equals("(")) {
break;
}
if ( Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
s2.add(s1.pop());
}
}
s1.push(item);
}
}
while (s1.size() != 0) {
s2.add(s1.pop());
}
return s2;
}
}
//编写一个类，可以返回一个运算符对应的优先级
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("不存在");
break;
}
return result;
}
}
2035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
