数据结构 - 栈(Stack)

最新推荐文章于 2024-07-23 16:53:03 发布
最新推荐文章于 2024-07-23 16:53:03 发布
阅读量2.7k 收藏 13
点赞数 4
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZSA222/article/details/124513383
版权

栈 数组模拟 运算符优先级 计算器实现 Java
关键词由CSDN通过智能技术生成

文章目录

栈的介绍

  • 栈的英文为(stack)。
  • 栈是一个先入后出(FILO : First In Last Out)的有序列表。
  • 栈（stack）是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊的线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）。
  • 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶；而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。

入栈(push)示意图

在这里插入图片描述

出栈(pop)示意图
在这里插入图片描述

用数组模拟栈

思路分析
在这里插入图片描述

  1. 使用数组模拟栈
  2. 定义一个 top 来表示栈顶，初始化 为 -1
  3. 入栈的操作，当有数据加入到栈时，top++; stack[top] = data;
  4. 出栈的操作， int value = stack[top]; top- -, return value;

代码实现

/**
 * @ClassName ArrayStackDemo
 * @author: shouanzh
 * @Description 数组模拟栈
 * @date 2022/4/30 15:57
 */
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);
        System.out.println("show：表示显示栈");
        System.out.println("exit：表示退出程序");
        System.out.println("push：表示添加数据到栈（入栈）");
        System.out.println("pop：表示从栈取出数据（出栈）");
        while (loop) {
            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;

    // top表示栈顶，初始化为-1
    private int top = -1;

    // 构造器 初始化栈的大小
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }


    /**
     * 判断栈满
     * @return boolean
     */
    public boolean isFull() {
        return top == maxSize - 1;
    }

    /**
     * 判断栈空
     * @return boolean
     */
    public boolean isEmpty() {
        return top == -1;
    }

    /**
     * 入栈
     * @param value 数据
     */
    public void push(int value) {
        // 判断栈是否已经满了
        if (isFull()) {
            System.out.println("栈已经满了～～");
            return;
        }

        // 栈顶++
        top++;
        // 存入数据
        stack[top] = value;
    }

    /**
     * 出栈 将栈顶数据返回
     * @return int
     */
    public int pop() {
        // 判断是否为空
        if (isEmpty()) {
            System.out.println("栈已经空了～～");
            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]);
        }
    }

}

栈实现计算器

思路分析

在这里插入图片描述

  1. 初始化两个栈，一个【数栈】和一个【符号栈】。
  2. 通过一个index值（索引），来遍历表达式。
  3. 如果发现是一个数字，就直接入【数栈】。
  4. 如果发现是一个运算符，就分情况讨论:
    1. 如果当前的【符号栈】为空，那就直接入栈。
    2. 如果当前的【符号栈】有操作符，就进行比较 ：
      1. 【当前的操作符】的优先级 <= 【符号栈中操作符】的优先级，就需要从【数栈】中pop出两个数，再从【符号栈】中pop出一个符号，然后进行运算，将得到结果入【数栈】。然后递归第4步，直到将【当前的操作符】push到【符号栈】为止。
      2. 【当前的操作符】的优先级 > 【符号栈中操作符】的优先级，就直接入符号栈。
  5. 当表达式扫描完毕，就顺序的从【数栈】和【符号栈】中pop相应的数和符号，并运算，将结果push到数栈。
  6. 最后【数栈】中只有一个数字就是表达式的结果。

代码实现

在这里插入图片描述

/**
 * @ClassName Calculator
 * @author: shouanzh
 * @Description 使用栈实现简单的计算器
 * @date 2022/4/30 19:57
 */
public class Calculator {
    public static void main(String[] args) {

        // 运算表达式
        String expression1 = "33+2+2*6-2";
        String expression2 = "7*22*2-5+1-5+3-4";
        String expression3 = "4/2*3-4*2-3-99";
        String expression4 = "1*1*1*3*2/3";
        String expression5 = "11*1*1*3*2/3";
        String expression6 = "1000*23";
        String expression7 = "1-1*1+9";

        // 创建两个栈：数栈、符号栈
        ArrayStack numStack = new ArrayStack(10);
        ArrayStack operationStack = new ArrayStack(10);

        test(expression1, numStack, operationStack);
        test(expression2, numStack, operationStack);
        test(expression3, numStack, operationStack);
        test(expression4, numStack, operationStack);
        test(expression5, numStack, operationStack);
        test(expression6, numStack, operationStack);
        test(expression7, numStack, operationStack);
    }

    /**
     * 测试方法，测试表达式的结果，并且打印结果
     * @param expression 表达式
     * @param numStack 数字栈
     * @param operationStack 符号栈
     */
    public static void test(String expression, ArrayStack numStack, ArrayStack operationStack) {
        // 用于扫描
        int index = 0;
        // 将每次扫描得到的char保存到ch
        char ch;

        // 开始while循环的扫描expression
        while (true) {
            // 依次得到expression的每一个字符
            ch = getCharByIndex(expression, index);
            // 判断ch是什么，然后做相应的处理
            if (isOperation(ch)) {
                // 运用管道过滤器风格，处理运算符
                operationSolve1(ch, numStack, operationStack);
            } else {
                // 数直接入数栈，对值为ASCII值-48
                // 当处理多位数时候，不能立即入栈，可能是多位数，调用过滤器处理多位数
                index = numSolve1(expression, index, numStack);
            }
            // 让index+1，并判断是否扫描到expression最后
            index++;
            if (index >=  expression.length()) {
                break;
            }
        }
        // 最后只剩下两个数和一个运算符
        int res = cal((int) numStack.pop(), (int) numStack.pop(), (char) operationStack.pop());
        System.out.printf("表达式: %s = %d\n", expression, res);
    }

    /**
     * 获取表达式的下标位置为index的字符
     * @param expression 表达式
     * @param index 下标
     * @return
     */
    public static char getCharByIndex(String expression, int index) {
        return expression.charAt(index);
    }

    /**
     * 处理数字入栈的情况，包含处理多位数的情况，并且返回到操作表达式当前的下标
     * @param expression 表达式
     * @param index 下标
     * @param numStack 数字栈
     * @return 新的下标
     */
    public static int numSolve1(String expression, Integer index, ArrayStack numStack) {
        // 在处理数，需要向expression的表达式的index 后再看一位，如果是数就进行扫描，如果是符号才入栈
        int end = index + 1;
        for (; end < expression.length(); end++) {
            char ch = getCharByIndex(expression, end);
            // 判断是不是数字
            if (!isOperation(ch)) {
                continue;
            } else {
                break;
            }
        }
        String numStr = expression.substring(index, end);
        // 数据入栈
        numStack.push(Integer.parseInt(numStr));
        // 因为test函数进行了+1，所以这里进行-1，避免给重复添加
        return end - 1;
    }

    /**
     * 符号过滤器1，判断当前是否具有字符
     * @param ch 运算符
     * @param numStack 数字栈
     * @param operationStack 运算符栈
     */
    public static void operationSolve1(char ch, ArrayStack numStack, ArrayStack operationStack) {
        // 判断当前符号栈是否具有操作符
        if (!operationStack.isEmpty()) {
            operationSolve2(ch, numStack, operationStack);
        } else {
            operationStack.push(ch);
        }
    }

    /**
     * 符号过滤器2，处理字符优先级，递归调用过滤器1
     * @param ch 运算符
     * @param numStack 数字栈
     * @param operationStack 运算符栈
     */
    public static void operationSolve2(char ch, ArrayStack numStack, ArrayStack operationStack) {
        // 比较优先级
        if (priority(ch) <= priority((Character) operationStack.peek())) {
            // 调用过滤器3进行计算
            operationSolve3(numStack,operationStack);
            // 递归调用过滤器1，不能递归调用过滤器2，因为可能存在当前运算符栈为空的情况
            operationSolve1(ch, numStack, operationStack);
        } else {
            // 直接将运算符加入到运算符栈中
            operationStack.push(ch);
        }
    }

    /**
     * 符号过滤器3，进行运算
     * @param numStack 数字栈
     * @param operationStack 运算符栈
     */
    public static void operationSolve3(ArrayStack numStack, ArrayStack operationStack) {
        // 定义相关变量
        int num1 = (int) numStack.pop();
        int num2 = (int) numStack.pop();
        char operation = (char) operationStack.pop();
        int res = cal(num1, num2, operation);
        // 把运算结果加到数栈
        numStack.push(res);
    }

    /**
     * 返回运算符的优先级，数字越大，运算符越高
     * @param operation 运算符
     * @return
     */
    public static int priority(char operation) {
        if (operation == '*' || operation == '/') {
            return 1;
        } else if (operation == '+' || operation == '-') {
            return 0;
        } else {
            // 假设目前的表达式只有 + - * /
            return -1;
        }
    }

    /**
     * 判断是不是运算符
     * @param val 字符
     * @return 是不是运算符
     */
    public static boolean isOperation(char val) {
        return val == '+' || val == '-' || val =='*' || val == '/';
    }

    /**
     * 计算结果
     * @param num1 操作数1，先出栈的数
     * @param num2 操作数2，后出栈的数
     * @param operation 操作符
     * @return 计算结果
     */
    public static int cal(int num1, int num2, char operation) {
        // 用于存放运算的结果
        int res = 0;
        switch (operation) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                // num1是先弹出来的数，为被减数
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                // num1是先弹出来的数，为被除数
                res = num2 / num1;
            default:
                break;
        }
        return res;
    }
}

/**
 * 定义一个ArrayStack表示栈
 */
class ArrayStack {

    // 栈的大小
    private int maxSize;

    // 数组模拟栈，数据就放在该数组中
    private Object[] stack;

    // top表示栈顶，初始化为-1
    private int top = -1;

    // 构造器 初始化栈的大小
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new Object[maxSize];
    }


    /**
     * 判断栈满
     * @return boolean
     */
    public boolean isFull() {
        return top == maxSize - 1;
    }

    /**
     * 判断栈空
     * @return boolean
     */
    public boolean isEmpty() {
        return top == -1;
    }

    /**
     * 入栈
     * @param value 数据
     */
    public void push(Object value) {
        // 判断栈是否已经满了
        if (isFull()) {
            System.out.println("栈已经满了～～");
            return;
        }

        // 栈顶++
        top++;
        // 存入数据
        stack[top] = value;
    }

    /**
     * 出栈 将栈顶数据返回
     * @return int
     */
    public Object pop() {
        // 判断是否为空
        if (isEmpty()) {
            System.out.println("栈已经空了～～");
            throw new RuntimeException("栈已经空了～～");
        }

        // 取得栈顶的值
        Object value = stack[top];
        // 栈顶--
        top--;
        // 返回值
        return value;
    }


    /**
     * 遍历栈 遍历时需要从栈顶开始显示数据
     */
    public void list() {
        // 判断是否为空
        if (isEmpty()) {
            System.out.println("栈已经空了～～");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.println(stack[i].toString());
        }
    }


    /**
     * 返回栈顶元素
     * @return Object
     */
    public Object peek() {
        // 判断是否为空
        if (isEmpty()) {
            System.out.println("栈已经空了～～");
            throw new RuntimeException("栈已经空了～～");
        }
        return stack[top];
    }

}

运行结果

表达式: 33+2+2*6-2 = 45
表达式: 7*22*2-5+1-5+3-4 = 298
表达式: 4/2*3-4*2-3-99 = -104
表达式: 1*1*1*3*2/3 = 2
表达式: 11*1*1*3*2/3 = 22
表达式: 1000*23 = 23000
表达式: 1-1*1+9 = 9

Process finished with exit code 0

🥳

Zhang_960110
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构__stack
chaoyueziji123的专栏
02-24 797
栈的定义及基本运算 1、栈的定义     　栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。 　　(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。 　　(2)当表中没有元素时称为空栈。 　　(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。     　栈的修改是按后进先出的原则进行。每次删除（退栈）的总
【数据结构】顺序栈 Stack
爱.NET
07-16 135
08年9月入学，12年7月毕业，结束了我在软件学院愉快丰富的大学生活。此系列是对四年专业课程学习的回顾，索引参见：http://blog.csdn.net/xiaowei_cqu/article/details/7747205 顺序栈各种基本运算算法的实现 栈是只能在某一端插入和删除的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底（push），最后的数据在栈顶（top...
数据结构：栈
最新发布
2301_79601095的博客
07-23 1696
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
数据结构——栈(stack)
qq_64191695的博客
07-06 982
栈(stack) 1.子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。 2.处理参数递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。 3.表达式的转换【中缀表达式转后缀表达式】和求值。 4.二叉树的遍历 5.图形的深度优先搜索法栈代码实现（数组）： 输出结果： 栈实现计算器： 中缀表达式的求值是平常最为熟悉的，但是对计算机说却不好操作（上述代码有些冗杂）。因此，在计算结束时，往往会将中缀表达
栈（stack）
指尖上的革新
10-11 1939
栈的简介 栈（stack） 栈是一个先入后出（FILO-first in last out）的有序列表。 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表，允许插入和删除的一端，为变化的一端，称为栈顶（top）,另一端为固定的一端，称为栈低（bottom） 根据栈的定义可知，最先放入栈中元素在栈低，最后放入元素宅栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除 应用场景 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆中，直到子程序执行完后再将地址取
常用数据结构之Stack(栈)
gaobing1993的博客
09-24 578
1.理论介绍 上一篇中我们介绍了数据结构中的堆，常言道堆栈不分家，我们继续来聊聊栈这种数据结构吧。栈从本质上来讲是一种有着特殊要求的线性表，感兴趣的可以了解一下之前讲的数据结构中的线性表。既然是线性表那么其就有两种形式，一种是线性存储(像数组一样是一块连续的内存空间)，另外一种是链式存储(像链表一样是一段非连续的空间)； 栈的特殊要求就是LIFO(Last In First Out)，对，后进先出。只有栈顶的元素允许访问。还记得上一篇讲的堆吗？从本质上来讲堆也是只有顶部的...
5.栈Stack
HK_Milky的博客
08-12 448
栈Stack 栈的简介 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除 出栈(pop)和入栈(pus)（图显） 栈的应用场景
基于C语言的数据结构-栈stack
06-25
在这个主题中，我们专注于栈（Stack）这一重要的数据结构，它是基于C语言实现的。栈是一种线性数据结构，遵循“后进先出”（LIFO，Last In First Out）原则，它的操作类似于日常生活中的堆叠物品，最新的添加的物品...
数据结构-栈.zip_数据结构-栈
09-24
5. **自定义栈的实现**：除了使用STL的`stack`，还可以自定义栈，例如使用动态数组或链表作为底层数据结构。自定义栈的优势在于可以根据需求定制栈的行为，如增加新的操作或优化性能。 综上所述，这个压缩包提供的...
数据结构-栈(Stack)介绍和Java示例代码
07-01
数据结构中的栈（Stack）是计算机科学中一种基础且重要的数据结构，它的核心特性是遵循后进先出（LIFO）原则。栈就像一个只允许在一端进行操作的线性容器，这一端被称为栈顶。栈的操作主要有两个基本操作：压栈...
基于python的数据结构代码实现-栈Stack
06-25
栈（Stack）是一种特殊类型的数据结构，遵循“后进先出”（Last In First Out, LIFO）原则。栈在许多算法和问题解决中都有广泛应用，如深度优先搜索、表达式求值等。本文将详细介绍如何在Python中实现一个基本的栈...
数据结构-栈stack（链栈，顺序栈）
[SZU_Crayon]
04-15 894
一、栈的概念1）介绍栈STL时已经有写，大家可以翻翻，传送门：点击打开链接2）没有提过栈底，栈底：在顺序栈中指的是 -1下标，大家自己往下看嘻嘻。二、顺序栈1.顺序栈图解2.特点    1）空间有限，因为是一次性分配数组空间，有栈满情况。    2）出栈入栈是下标top变化，实际出栈只是下标后退一位，实际数值还在数组中，浪费内存。3.扔一段代码/*顺序栈*/ #include&lt;iostrea...
数据结构系列之Stack
weixin_41909603的博客
09-30 492
本期文章介绍的是另一种数据结构Stack。 Stack的主要特征有两个，分别是：(1) 是一种抽象数据结构。抽象的数据结构在上期文章(https://blog.csdn.net/weixin_41909603/article/details/101525345)中已介绍，在此不赘述。(2) LIFO，即Last In First Out，指的是在Slack中删除元素时，最后被添加进Slack的元素...
栈（Stack）
CvShrimp的博客
12-20 278
栈（Stack）栈（Stack）是一种基本的数据结构，它有先进先出的特性，有入栈、出栈等操作，下面给出栈的Java实现 /** * Created by CvShrimp on 2017/10/21. */ public class Stack<T> { private Node top; private int size = 0; private class Node {
栈（stack)
jinghang2000的博客
12-30 575
1.定义： 栈（stack)一种特殊（只允许在一端进行插入或删除操作）的线性表。 现实例子：一摞盘子只能在盘子最上面操作，烤串，羽毛球盒放取羽毛球，都只能在顶部 2.栈的术语 栈顶：允许进行插入删除的一端 栈底：不允许进行插入删除的一端 3.栈的特点： 后进先出（Last in First Out) （给进栈顺序，选合法出栈顺序） 4.栈的基本操作： 5.顺序栈 //顺序栈 #define MaxSize 10 typedef struct{ int data[MaxS.
常用数据结构Stack
菜鸟先飞
01-10 387
 Stack: public class Stack {  private static final int DEFAULT_SIZE = 5;  // 主数据结构  private Object elementObject[];  // 当前的位置  private int index;  // 数组大小  private int size;  private
栈的链式存储结构的简单实现
qq_43411563的博客
04-22 687
上一篇博客我们进行了栈的顺序存储结构的简单实现，这一篇博客进行栈的链式存储结构的简单实现 一、链栈的定义 我们都知道栈有栈顶指针，链表有头指针，这两者是缺一不可的，所以在进行链栈的设计的时候，我们就把栈顶放在单链表的头部。从而方便我们的插入和删除的操作。那么链栈的基本结构如下所示： 二、链栈的简单实现 1、链栈的整体结构的定义 typedef int ElemType; typedef stru...
浅谈栈（Stack）数据结构
bc_Reversing的博客
04-28 1648
一、概述： 栈（stack）：栈是一种线性的结构，这种数据结构仅限在线程表的一段进行插入和删除操作。其中线性表插入的和删除的一段称为栈顶（top），不循序插入和删除的一段称为栈底（bottom）。所以栈数据结构是遵循“后入先出”，也就是“LIFO”。 二、栈的特征 （1）栈也是一种线性的机构。 （2）相比较数组，占对应的操作是数组的子集。 （3）只能从一端添加元素，也只能从一端取出元素，这一端称为栈顶。 （4）栈是一种后进先出的数据结构。称为：Liast In First Out（LIFO）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值