本文介绍了栈这一数据结构的基本概念，包括其先入后出的特性以及在子程序调用、递归处理、表达式转换等方面的应用。通过代码示例展示了如何使用数组模拟栈的入栈、出栈操作，并详细解释了栈在实现综合计算器，特别是中缀表达式转后缀表达式计算过程中的关键作用。
栈 （ 一 ）
栈的介绍
- 栈的英文为(stack)
- 栈是一个先入后出(FILO-First In Last Out)的有序列表。
- 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
- 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
栈的应用场景
- 子程序的调用:在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
- 处理递归调用:和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆z栈中。
- 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
- 二叉树的遍历。
- 图形的深度优先(depth一 first)搜索法。
栈的快速入门
-
用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存储栈的数据内容，下面我们用数组模拟栈的出栈，入栈等操作。
-
实现思路分析： 使用数组来模拟栈
定义一个top ，来表示栈顶，初始化为-1.
入栈的操作，当有数据加入到栈时，top++;stack[top] = data;
出栈的操作 ，int value = stack[top];top – ;return value;
代码实现
package com.yuxi.lesson04;
import java.util.Scanner;
public class ArrayStackDemo {
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.printf("出栈的数据是 %d \n",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;//数组模拟栈，数据放在该数组
private int top = -1;//top 表示栈顶。初始化为-1;
//构造器
public ArrayStack(int maxSize){
this.maxSize = maxSize;
stack = new int[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]);
}
}
}
栈实现综合计算器
中缀表达式
思路 ：
package com.yuxi.lesson04;
public class Calculator {
public static void main(String[] args) {
String expression = "30+1-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 = "";//用于拼接 多位数
//开始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); //考虑扫描时字符
//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[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 var){
return var == '+'|| var == '-'||var == '*'||var == '/';
}
//计算方法
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;
}
}
40万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
