栈
栈的引入及介绍
（1）栈的引入
（2）栈的介绍
- 栈的英文为(stack)
- 栈是一个先入后出(FILO-First In Last Out)的有序列表。
- 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
- 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
（3）出栈（pop）和入栈（push）
（4）栈的应用场景
- 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
- 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
- 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
- 二叉树的遍历。
- 图形的深度优先(depth一first)搜索法。
栈的实现
（1）实现 栈的 思路分析
- 使用数组来模拟栈
- 定义一个 top 来表示栈顶，初始化 为 -1
- 入栈的操作，当有数据加入到栈时，
top++; stack[top] = data; - 出栈的操作，
int value = stack[top]; top--, return value
（2）代码实现
//定义一个类表示栈结构
class ArrayStack{
private int maxSize;//栈的大小
private int[] stack;//数组，数组模拟栈，数组就放在该数组
private int top = -1;//栈顶
//构造器
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 RuntimeException("栈空，没有数据//");
}
int value = stack[top];
top--;
return value;
}
//显示栈的情况【遍历栈】,遍历时，需要从栈顶开始显示数据
public void list() {
//先判断栈是否空
if(isEmpty()) {
//抛出异常
throw new RuntimeException("栈空，没有数据//");
}
for(int i = top;i>=0;i--) {
System.out.printf("stack[%d]=%d \n",i,stack[i]);
}
}
}
使用栈完成计算 一个表达式（中缀表达式）
（1）思路分析
- 通过一个 index 值（索引），来遍历我们的表达式
- 如果我们发现是一个数字, 就直接入数栈
- 如果发现扫描到是一个符号, 就分如下情况
3.1 如果发现当前的符号栈为空，就直接入栈
3.2 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数,在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈， 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈. - 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
- 最后在数栈只有一个数字，就是表达式的结果
（2）代码实现
package NO03;
public class Calculator {
public static void main(String[] args) {
//根据思路完成表达式的运算
String expression = "70+2*6-4";
//创建两个栈，数栈，符号栈
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);
}
}else {//如果我们发现是一个数字, 就直接入数栈
// numStack.push(ch-48);//ascall码表中字符1与数字1相差48
//当处理多位数时，不能发现是一位数就立即入栈，因为它可能是多位数
//在处理数时，需要向expression的表达式的index后再看一位，如果是数就进行扫描，如果是符号才入栈
//因此我们需要定义一个变量 字符串，用于拼接
//处理多位数
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清空
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出来，计算结果
System.out.printf("表达式%s = %d",expression,numStack.pop());
}
}
//创建一个栈
//定义一个类表示栈结构，需要扩展功能
class ArrayStack2{
private int maxSize;//栈的大小
private int[] stack;//数组，数组模拟栈，数组就放在该数组
private int top = -1;//栈顶
//构造器
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 RuntimeException("栈空，没有数据//");
}
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];
}
}
注意：这里由实现一位数的运算拓展到实现多位数的运算
前缀表达式(波兰表达式)
（1）介绍：
- 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前
- 举例说明： (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6
（2）前缀表达式的计算机求值
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
后缀表达式（逆波兰表达式）
（1）介绍
- 后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后
- 举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –
（2）后缀表达式的计算机求值
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果
（3）完成一个逆波兰计算器
任务点：
- 输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果
- 支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。
- 思路分析
- 代码完成
代码实现：
package NO03;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static void main(String[] args) {
// 先定义一个逆波兰表达式
//(3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 -
//为了方便，逆波兰表达式 的数字和符号使用空格隔开
String suffixExpression = "30 4 + 5 * 6 -";
//思路：
//1.先将"3 4 + 5 × 6 -"放到ArrayList中
//2.将ArrayList 传递给一个方法，遍历 配合栈完成计算
List<String> list = getListString(suffixExpression);
System.out.println("List="+list);
int res = calculate(list);
System.err.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;
}
//完成对逆波兰表达式的运算
/**
*
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 static int calculate(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;
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("运算符有误");
}
//把res入栈
stack.push(""+res);
}
}//最后留在stack中的数据就是运算结果
return Integer.parseInt(stack.pop());
}
}
267
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
