08_栈（附数组及单链表的java代码实现）

最新推荐文章于 2021-08-24 21:07:56 发布
最新推荐文章于 2021-08-24 21:07:56 发布
阅读量132 收藏 1
点赞数
分类专栏： Java数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jrrhjww/article/details/108966060
版权

堆栈 链表 java 数据结构

08_栈

一、问题引入

请输入一个表达式

计算式：[7x2x2-5+1-5+3-3]，点击计算（如图所示）
在这里插入图片描述
请问：计算机底层是如何运算得到结果的?注意不是简单的把算式列出运算,因为我们看这个算式7x2x2-5+1-5+3-3，但是计算机怎么理解这个算式的(对计算机而

言，它接收到的就是一个字符串)，我们讨论的就是这个问题 --> 栈

二、栈的介绍

​ 1）栈的英文为(stack)；

​ 2）栈是一个先入后出(FILO-First In Last Out)的有序列表；

​ 3）栈(stack)是限制线性表中元素的插入和删除，只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)；

​ 4）根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。

​ 5）图解出栈与入栈的概念：
在这里插入图片描述

三、栈的应用场景

​ 1）子程序的调用:在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。

​ 2）处理递归调用:和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。

​ 3）表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。

​ 4）二叉树的遍历。

​ 5）图形的深度优先(depth-first)搜索法。

四、数组模拟栈

4.1 思路分析

​ 1）使用数组来模拟栈

​ 2）定义一个top来表示栈顶，初始化为-1

​ 3）入栈的操作，当有数据加入到栈时，top++;stack[top]=data;

​ 4）出栈的操作，int value = stack[top];top–;return value;

数组模拟栈思路分析图
数组模拟栈思路分析图

4.2 代码实现

public class ArrayStackDemo {
    public static void main(String[] args) {
        //验证数组模拟栈的正确性

        //先创建一个ArrayStack对象
        ArrayStack arrayStack = new ArrayStack(5);

        arrayStack.list();

        arrayStack.push(10);
        arrayStack.push(20);
        arrayStack.push(30);
        arrayStack.push(40);
        arrayStack.push(50);
        arrayStack.push(60);
        arrayStack.list();

        int value = arrayStack.pop();
        System.out.println(value);
        arrayStack.list();
    }
}

//定义一个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[this.maxSize];
    }

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

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

    //入栈-push
    public void push(int value){
        //判断栈是否已满
        boolean flag = isFull();
        if (flag){
            System.out.println("该栈已满，无法插入数据！");
        }else{
            System.out.println("该栈未满，可以插入数据！");
            top++;
            stack[top] = value;
        }
    }

    //出栈-pop
    public int pop(){
        //判断栈是否为空栈
        boolean flag = isEmpty();
        if (flag){
            throw new RuntimeException("该栈已空，无法弹出数据！");
        }else {
            System.out.println("该栈未空，可以弹出数据！");
            int value = stack[top];
            top--;
            return value;
        }
    }

    //显示栈的所有元素--遍历栈（遍历时需要从栈顶开始显示数据）
    public void list(){
        //判断栈是否为空
        if (isEmpty()){
            System.out.println("该栈已空，无法弹出数据！");
            System.out.println("-------------------");
            return;
        }

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

        System.out.println("-------------------");
    }
}

五、链表模拟栈

5.1 代码实现

public class LinkedListStackDemo {
    public static void main(String[] args) {
        //验证单链表模拟栈的正确性

        //先创建一个LinkedListStack对象
        LinkedListStack linkedListStack = new LinkedListStack(new SingleLinkedList());

        linkedListStack.showStack();

        linkedListStack.push(10);
        linkedListStack.push(20);
        linkedListStack.push(30);

        linkedListStack.showStack();

        int value = linkedListStack.pop();
        System.out.println(value);
        linkedListStack.showStack();
    }
}

//定义一个LinkedListStack类表示栈结构
class LinkedListStack{
    private SingleLinkedList list;

    public LinkedListStack(SingleLinkedList list) {
        this.list = list;
    }

    //判断栈空
    public boolean isEmpty(){
        return list.getLength() == 0;
    }

    //入栈-push
    public void push(int value){
        Node node = new Node(value,null);
        list.add(node);
    }

    //出栈-pop
    public int pop(){
        //判断栈是否为空栈
        boolean flag = isEmpty();
        if (flag){
            throw new RuntimeException("该栈已空，无法弹出数据！");
        }else {
            System.out.println("该栈未空，可以弹出数据！");
            return list.delete();
        }
    }

    //显示栈的所有元素--遍历栈（遍历时需要从栈顶开始显示数据）
    public void showStack(){
        //判断栈是否为空
        if (isEmpty()){
            System.out.println("该栈为空栈！");
            System.out.println("-------------------");
            return;
        }

        list.reversePrint(list.getHead());
    }
}

//定义SingleLinkedList来管理节点
class SingleLinkedList{
    //先初始化一个头结点（一般不存放具体数据）
    private Node head = new Node(null,null);

    public Node getHead() {
        return head;
    }

    public SingleLinkedList() {
    }

    public SingleLinkedList(Node head) {
        this.head = head;
    }

    /*
            添加节点到单链表
            当不考虑编号顺序时
                1.找到当前链表的最后节点
                2.将尾结点的next指向新节点
        */
    public void add(Node node){
        //因为head节点不能动，所以创建一个辅助遍历的节点temp
        Node temp = head;
        //遍历链表，寻找尾结点
        while (true){
            //该节点已经是尾结点及跳出循环
            if (temp.next == null){
                break;
            }
            //若仍不是尾结点则继续遍历
            temp = temp.next;
        }

        //退出while循环时，temp就指向了链表的尾结点
        //将尾结点的next指向要插入的新节点
        temp.next = node;
    }

    //删除尾节点思路：当temp.next.next == null时，删除该节点
    public int delete(){
        Node temp = head;
        while (true){
            if (temp.next.next == null){
                //已经到链表的最后
                break;
            }

            temp = temp.next;
        }
        int value = temp.next.value;
        //删除尾节点
        temp.next = null;
        return value;
    }


    //显示链表（遍历）
    public void showList(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("该链表为空链表！");
            return;
        }

        //因为头节点不能动，所以使用一个辅助节点进行遍历
        Node temp = head.next;
        while (true){
            if (temp.next == null){
                System.out.println(temp);
                break;
            }

            System.out.println(temp);
            temp = temp.next;
        }
    }

    //显示链表长度(遍历)
    public int getLength(){
        int length = 0;

        //判断链表是否为空
        if (head.next == null){
            return length;
        }

        //因为头节点不能动，所以使用一个辅助节点进行遍历
        Node temp = head.next;
        while (true){
            if (temp.next == null){
                break;
            }
            length++;
            temp = temp.next;
        }

        return length;
    }

    //可以使用栈将各个节点压入到栈中，然后利用栈的先进后出的特点，实现逆序打印
    public void reversePrint(Node head){
        //创建一个栈stack，将各个节点压入栈
        Stack<Node> stack = new Stack<>();
        Node cur = head.next;
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }

        //将栈中的节点pop出栈并打印
        while (stack.size() > 0){
            System.out.println(stack.pop());
        }
    }
}

//定义一个Node类，每个Node对象就是栈中的一个节点
class Node{
    public Integer value;
    public Node next;   //指向下一个节点

    //构造方法
    public Node(Integer value, Node next) {
        this.value = value;
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
}
jrrhjww
关注
专栏目录
数据结构-栈（二）综合计算器（Java）
weixin_43265151的博客
03-08 283
1.综合计算器实现思路分析 本文的综合计算器包含的运算符有+，-，*，/ 完成一个综合计算器需要考虑到一个多项式中各个符号的优先级，如果不考虑运算符的优先级就会出现错误的答案，所以在获取多项式的各个项的时候需要对拿到的符号进行判断。 数据结构的选择： 栈，利用栈的特性，可以有顺序的倒序取出数据 使用两个栈放不同类型的数据，stack1(数字栈)，stack(符号栈) 1.1 如何对不同优先级的...
使用java代码编写栈来实现综合计算器(中缀表达式)
a1786742005的博客
01-22 586
一、使用栈实现综合计算器思路 二、编写代码 2.1 编写ArrayStack2类 package point2; /** * @description: 定义一个栈 * @author: hyr * @time: 2020/1/21 19:58 */ public class ArrayStack2 { private int maxSize; // 栈的大小 priv...
JAVA_栈实现综合计算器
TOPic666的博客
09-15 209
图例 代码 package com.Calculator; import java.util.Stack; public class Calculator { public static void main(String[] args) { String expression = "30+2*6-2"; Stack<Integer> numStack = new Stack<>(); Stack<Character&
Java-数据结构与算法--栈实现综合计算器
weixin_45508650的博客
08-15 245
栈实现综合计算器（中缀表达式） 思路分析： 需要两个栈： 数栈和符号栈 定义一个index索引来遍历表达式 遍历到一个数字，则入数栈 遍历到一个符号，若符号栈为空则入符号栈； 若符号栈不为空：如果当前遍历到的符号优先级小于或等于符号栈中符号的优先级，则从数栈中pop出两个数，从符号栈中pop出一个符号，进行运算，然后将运算结果入数栈，将当前遍历到的符号入符号栈；如果当前遍历到的符号优先级大于符号栈中符号优先级，则将该符号直接入符号栈。 表达式遍历完毕后，则按顺序从数栈和符号栈中pop出值进行运算 最后数栈
java的数据结构与算法（11）使用栈来实现综合计算器
cxl234的博客
07-31 391
需求： 大致思路分析： 这个表达式过去复杂换一个简单的来进行测试 开始代码部分： package cn.itjy.Stack; public class Cslculator { public static void main(String[] args) { // 根据前面思路，完成表达式的运算 String expression = "7+2*6-4"; // 创建两个栈...
线性表，单链表，栈 java实现
12-09
Java中栈的实现可以使用`java.util.Stack`类，它是`Vector`类的子类，提供了`push()`, `pop()`, `peek()`等方法。 在给定的文件“王倩”中，很可能包含了实现这些数据结构的Java源代码。通过阅读和理解这些代码，你...
通过数组创建单链表——链表删除重复的元素
your_棒棒糖的博客
08-24 567
链表删除重复的元素 参考链接：https://blog.csdn.net/feinifi/article/details/94460480 控制台输入一组数组，将数组转换成链表，构建链表，将链表中重复的元素删除 （1）将当前节点的上一个节点的next指向当前节点的next public LinkNode removeElements(LinkNode head,int val){ //如果头结点是要删除的节点，那么直接跳出循环 //如果头结点是要删除的节点，直接head =
单链表的基本操作实现-查找_单链表的基本操作实现_
09-29
单链表是一种基础的数据结构，广泛应用于计算机科学和编程领域。...通过阅读“2-1-单链表的基本操作实现-查找.pdf”文件，你可以深入了解单链表查找的具体步骤、算法实现和示例代码，进一步提升对单链表操作的理解。
数据结构线性表初学--单链表、队列、栈的java使用数组实现
dadadajuzi的博客
04-21 97
数据结构线性表初学--单链表、队列、栈的java实现21.04.19java小计单链表栈队列上述拙见 有不对之处 欢迎各位大佬指出 21.04.19java小计 数据结构线性表初学–单链表、队列、栈的java实现 如何在java中通过数组作为容器 实现线性表的单链表、队列和栈 单链表 不同于数组，在链表在内存中并不是物理连续的，可以说是逻辑连续，每个节点含有一个data，通过每个节点的next指向下一个节点的地址。因为这个原因，使得我们的链表在进行增删操作时效率大大超出数组，但是查询（也就是数组的寻址）效率
基于Java实现的单链表基本操作之获取链表长度.zip
最新发布
04-26
通过学习如何在Java中实现单链表，包括获取链表长度的方法，你可以更好地理解和运用数据结构，这对于编写高效且优化的代码至关重要。在实际编程中，结合实际场景选择合适的数据结构，将有助于解决各种问题。
Java综合程序设计——计算器（实现运算符优先级的四则混合运算）
06-19
一个计算器，有多种功能，如取对数、求平方根。最重要的是利用堆栈算法实现运算符优先级。
数据结构与算法：09 栈与递归
老马的程序人生
09-20 621
09 栈 知识结构： 栈是我们经常使用的一种数据结构，比如，手枪发射子弹的顺序与子弹压入弹夹的顺序是相反，即后压入弹夹的子弹先发射出来。又比如，我们使用的Word、Excel、Photoshop等软件系统中的撤销操作，也是栈的具体应用，最后做的操作，一定是最先撤销的。 下面我们就来详细介绍“栈”这种数据结构。 1. 栈的定义与操作 1.1 栈的定义 插入（入栈）和删除（出栈）操作只能在一端（栈顶）进行的线性表。即先进后出（First In Last Out）的线性表。 例1 ：线性表$(a_0,a_1,
java栈实现综合计算器
dongyu1703的博客
08-15 897
代码： package course; public class Calculator { public static void main(String[] args) { // 完成表达式的运算 String exp = "70+20*6-4"; // 创建两个栈，一个数栈一个符号栈 ArrayStack2 numStack = new ArrayStack2(10)...
数据结构~09.顺序栈和链栈的应用
热门推荐
qq_41424688的博客
07-29 3万+
数据结构学习~09.顺序栈和链栈的应用 本文是上一篇文章的后续,详情点击该链接~
Java写的一个计算器(用堆栈实现复杂运算)
qq_20698983的博客
03-02 5781
运算效果 核心类 package cn.xt.calculator; import java.util.Stack; public class Calculator { private Stack&lt;Character&gt; charStack = new Stack&lt;Character&gt;(); private Stack&lt;Double&...
【计算器Java实现】基于栈的复杂表达式解析&&数值计算
adiaixin123456的专栏
10-14 2667
该实现可以计算复杂的计算表达式，做了几个测试通过，如下所示： +(12.3 - 2.3 * 1) - 10/3 +- 2  -pow(min(1 + 2, 2),-1 * abs(max(1,1/-4+1/4))) 由于所有的复杂表达式都可以拆解为二元运算，或者一元运算，我们定义了一些基础的运算符，如下枚举，如果需要其他的可以自己在枚举中添加，并且在NumericalCalculat
栈的基本操作（进栈，出栈）
这是一个菜鸡的博客
09-20 8928
#include <stdio.h> #define MAX_STACK_SIZE 100 #typedef int ElmType; typedef struct sqstack { ElemType stack_array[MAX_STACK_SIZE]; int top; }SqStack; //栈的初始化 SqStack Init_Srack(void) { SqSt
13_冒泡算法(附完整java代码)
jrrhjww的博客
12-11 791
13_冒泡算法 一、基本介绍 ​ 冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。 ​ 因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行) 二、图示冒泡排序
30_哈夫曼树
jrrhjww的博客
04-21 652
30_哈夫曼树 一、算法概念介绍 1.1 基本概念 ​ 1)路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1； ​ 2)结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积； ​ 3)树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WP
Java数据结构详解：数组、链表、栈与队列
总结来说，理解并掌握数据结构对Java开发者至关重要，它不仅影响代码的效率，还影响程序的可读性和维护性。通过灵活运用数组、链表、栈、队列和树等数据结构，开发者能够构建出高效且功能强大的软件系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值