图解栈和队列实现

最新推荐文章于 2022-04-20 08:29:41 发布
最新推荐文章于 2022-04-20 08:29:41 发布
阅读量832 收藏
点赞数
分类专栏： Java 文章标签： 队列 链表 数据结构 queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ormosia2/article/details/109499839
版权

栈和队列

栈的实现
  1. 顺序栈，数组实现

在这里插入图片描述

class stackOfArray{
    public int[] elem;
    public int usedsize;
    public stackOfArray() {
        this.elem = new int[5];  //初始设置为5
    }

    public void push(int value) {  //往栈中压入元素
     if(isFull()) {
      //栈满时也可以扩容 this.elem = Arrays.copyOf(this.elem,this.elem.length * 2);
         System.out.println("栈满，无法push");
         return;
     }
     this.elem[this.usedsize] = value;
     this.usedsize++;
    }

    public void pop() {  //获取栈顶元素，并删除
        if (isEmpty()) {
            System.out.println("栈空，不能pop");
            return;
        }
        System.out.println(this.elem[this.usedsize - 1]);
        this.usedsize--;
    }

    public void peek() {  //获取栈顶元素，不删除
        if (isEmpty()) {
            System.out.println("栈空，不能peek");
            return;
        }
        System.out.println(this.elem[this.usedsize - 1]);
    }

    public boolean isEmpty() {  //判空
        if(this.usedsize == 0) {
            return true;
        }
        return false;
    }

    public boolean isFull() {  //判满
        if (this.elem.length == this.usedsize) {
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "stackOfArray{" +
                "elem=" + Arrays.toString(elem) +
                '}';
    }
}
  1. 泛型实现顺序栈
    //泛型实现顺序栈，主要将类改为泛型类
//上述顺序栈代码只需更改以下几处
class stackOfArray<T>{  //添加泛型
    public T[] elem; //泛型
    public int usedsize;
    public stackOfArray() {
        this.elem = (T[]) new Object[5];
    }

    public void push(T value) {  //往栈中压入元素  //参数也为泛型
     if(isFull()) {
         this.elem = Arrays.copyOf(this.elem,this.elem.length * 2);
//         System.out.println("栈满，无法push");
//         return;
     }
     this.elem[this.usedsize] = value;
     this.usedsize++;
    }
}
  2. 单链表实现栈

    单链表实现栈，使用头插、头删方法效率最高，时间复杂度为O(1).

在这里插入图片描述

class myNode{
    public int val;
    public myNode next;
    public myNode(int value) {
        this.val = value;
    }
}
class stackOfListNode{
    public myNode head;  //头节点

    public void push(int value) {  
        myNode node = new myNode(value);
    if (isEmpty()) {
        this.head = node;
    }else {
        node.next = this.head;  //头插
        this.head = node;
    }
    }

    public void pop() {
    if (isEmpty()) {
        System.out.println("栈空，无法pop");
    }else {
        System.out.println(this.head.val);  
        this.head = this.head.next; //头删
    }
    }

    public void peek() {
    if (isEmpty()) {
        System.out.println("栈空，无法peek");
    }else {
        System.out.println(this.head.val);
    }
    }

    public boolean isEmpty() {
     if(this.head == null) {
         return true;
     }
     return false;
    }

    public void display() {
        myNode cur = this.head;
        while(cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}
队列的实现
  1. 链表实现队列

在这里插入图片描述

class myQueueNode{
    public int val;
    public myQueueNode next;
    public myQueueNode(int value) {
        this.val = value;
    }
}
class queueOfListNode{
    //使用带尾节点的单链表
    public myQueueNode head;
    public myQueueNode tail;

    public void offer(int val) {  //入队
        myQueueNode node = new myQueueNode(val);
        if (isEmpty()) {
            this.head = node;
            this.tail = node;
        }else {
            this.tail.next = node;
            this.tail = node;
        }
    }

    public void poll() {  //出队，并删除
        if (isEmpty()) {
            System.out.println("队空，不能poll");
        }else {
            int temp = this.head.val;
            this.head = this.head.next;
            System.out.println(temp);
        }
    }

    public void peek() {  //出队，不删除
        if (isEmpty()) {
            System.out.println("队空，不能peek");
        }else {
            System.out.println(this.head.val);
        }
    }

    public boolean isEmpty() {  //判空
        if(this.head == null) {
            return true;
        }
        return false;
    }

    public void display() {
        myQueueNode cur = this.head;
        while(cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}
  1. 数组实现循环队列

在这里插入图片描述

class circularQueue{
    public int[] elem;
    public int front;
    public int rear;
    public circularQueue(int cap) {
        this.elem = new int[cap + 1];  //浪费一个空间，以便于判断队满队空
    }

    public void enQueue(int value) {
    if (isFull()) {
        System.out.println("队满,不能入队");
    }else {
        this.elem[this.rear] = value;
        this.rear = (this.rear + 1) % this.elem.length;
    }
    }

    public void deQueue() {
    if (isEmpty()) {
        System.out.println("队空,不能出队");
    }else {
        System.out.println(this.elem[this.front]);
        this.front = (this.front + 1) % this.elem.length;
    }
    }


    public void getRear() {
    if (isEmpty()) {
        System.out.println("队空，不能getRear");
    }else {
        int index = this.rear == 0 ? this.elem.length - 1 : this.rear - 1;
        System.out.println(this.elem[index]);
    }
    }

    public void getFront() {
        if (isEmpty()) {
            System.out.println("队空，不能getFront");
        }else {
            System.out.println(this.elem[this.front]);
        }
    }

    public boolean isEmpty() {  //rear == front时队空
    if (this.rear == this.front) {
        return true;
    }
    return false;
    }

    public boolean isFull() {  //当（rear + 1） % this.elem.length == front时队满
     if ((this.rear + 1) % this.elem.length == this.front) {
         return true;
     }
     return false;
    }

    @Override
    public String toString() {
        return "circularQueue{" +
                "elem=" + Arrays.toString(elem) +
                '}';
    }
}

  1. 数组双端循环队列

    类似于循环队列，区别在于，双端队列支持头部删除插入，尾部也可以删除插入。

    class double_queue {
    public int[] elem;
    public int front;
    public int rear;
    public double_queue(int cap) {
        this.elem = new int[cap + 1]; //浪费一个空间，以便于判断队满队空
    }

    public void addRear(int value) {  //队尾添加元素
        if (isFull()) {
            System.out.println("队满，不能addRear");
        }else {
            this.elem[this.rear] = value;
            this.rear = (this.rear + 1) % this.elem.length;
        }
    }

    public void addFront(int value) {  //队头添加元素
        if (isFull()) {
            System.out.println("队满，不能addFront");
        }else {
            this.front = this.front == 0 ? this.elem.length - 1 : this.front - 1;
            this.elem[this.front] = value;
        }
    }

    public void deleteRear() { //从队尾删除元素，并输出
        if (isEmpty()) {
            System.out.println("队空，无法deleteRear");
        }else {
            this.rear = this.rear == 0 ? this.elem.length - 1 : this.rear - 1;
            System.out.println(this.elem[this.rear]);
        }
    }

    public void deleteFront() {  //从队头删除元素，并输出删除了哪个元素
        if (isEmpty()) {
            System.out.println("队空，不能deleteFront");
        }else {
            int temp = this.elem[this.front];
            this.front = (this.front + 1 ) % this.elem.length;
            System.out.println(temp);
        }
    }


    public int getFront() {  //获取队头元素
        if (isEmpty()) {
            System.out.println("队空，不能getFront");
            return -1;
        }
        return this.elem[this.front];
    }

    public int getRear() {  //获取队尾元素
        if (isEmpty()) {
            System.out.println("队空，不能getRear");
            return -1;
        }
        int index = this.rear == 0 ? this.elem.length - 1 : this.rear - 1;
        return this.elem[index];
    }


    public boolean isEmpty() {  //判空
        if (this.front == this.rear) {
            return true;
        }
        return false;
    }

    public boolean isFull() {  //判满
        if ((this.rear + 1) % this.elem.length == this.front) {
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "double_queue{" +
                "elem=" + Arrays.toString(elem) +
                '}';
    }
}
*队列实现栈

在这里插入图片描述

class stack_with_queue{
    public Queue<Integer> que1;
    public Queue<Integer> que2;
    public int usedsize;
    public stack_with_queue(){
        this.que1 = new LinkedList<>();
        this.que2 = new LinkedList<>();
    }

    public void push(int val) {  //队不为空就放，两个队都为空随机选一个放
        if (!this.que1.isEmpty()) {
            this.que1.offer(val);
        }else if(!this.que2.isEmpty()){
            this.que2.offer(val);
        }else {
            this.que1.offer(val);
        }
        this.usedsize++;
    }

    public void pop() {  //队不为空，把队里前size-1个移到空队中，然后poll最后一个
        if (isEmpty()) {
            System.out.println("队空，无法pop");
            return;
        }
        int i = this.usedsize - 1;
        if (!this.que1.isEmpty()) {
           while(i > 0) {
               this.que2.offer(this.que1.poll());
               i--;
           }
            this.usedsize--;
            System.out.println(this.que1.poll());

        }else if (!this.que2.isEmpty()) {
          while(i > 0) {
              this.que1.offer(this.que2.poll());
              i--;
          }
            this.usedsize--;
            System.out.println(this.que2.poll());
        }
    }

    public void peek() {  //队不为空，就把所有元素移到空的里面，temp标记的就是栈的顶端节点
    if (isEmpty()) {
        System.out.println("队空，无法peek");
        return;
    }
    int index = this.usedsize;
    int temp = -1;
    if(!this.que1.isEmpty()) {
        while(index > 0) {
            temp = this.que1.poll();
            this.que2.offer(temp);
            index--;
        }
    }else if(!this.que2.isEmpty()) {
        while(index > 0) {
            temp = this.que2.poll();
            this.que1.offer(temp);
            index--;
        }
    }
        System.out.println(temp);
    }

    public boolean isEmpty() {
        if (this.que2.isEmpty() && this.que1.isEmpty()) {
            return true;
        }
        return false;
    }
}
*栈实现队列

在这里插入图片描述

class queue_with_stack{
    Stack<Integer> s1;  //只入队
    Stack<Integer> s2;  //只出队
    public queue_with_stack() {
        this.s1 = new Stack<>();
        this.s2 = new Stack<>();
    }

    public void offer(int value) {
     this.s1.push(value);
    }

    public void poll() {  //全部移到s2，然后pop s2的顶端数据
    if (this.s2.isEmpty()) {
        while(!this.s1.isEmpty()) {
            this.s2.push(this.s1.pop());
        }
    }
    if (!this.s2.isEmpty()) {
         int temp = this.s2.pop();
        System.out.println(temp);
    }
    }

    public void peek() {  //同poll一样，全部移到s2，peek顶端数据
    if(this.s2.isEmpty()) {
        while(!this.s1.isEmpty()) {
            this.s2.push(this.s1.pop());
        }
    }
    if(!this.s2.isEmpty()) {
        int temp = this.s2.peek();
        System.out.println(temp);
    }
    }

    public boolean isEmpty() {
     if(this.s1.isEmpty() && this.s2.isEmpty()) {
         return true;
     }
     return false;
    }
}
pandachen1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
利用堆栈和队列实现图的深度优先遍历和广度优先遍历
zsw_404的博客
12-26 1万+
//图的存储结构为邻接表 #include #include #define MaxVex 100 int visited[MaxVex]; //全局数组,用于记录图中节点访问状态 typedef struct EdgeNode { //邻接表节点 int adjvex; //该邻接点在顶点数组中的下标 struct EdgeNode *next; //指向下一个
栈、队列(详细图解与代码实现)
YOLO97的博客
09-07 3905
栈 栈是一种只能在一端进行插入和删除的线性数据结构。主要有进栈(Push)和出栈(POP)两个操作。 - 栈的存储结构 栈一般使用一段连续的空间进行存储，通常预先分配一个长度，可以简单地使用数组去实现，具体的存储结构如下图所示： - 栈的特点 只能在一端进行操作，在遵循先进后出(FILO,First In Last Out)或后进先出(LIFO,Last In First Out...
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4340
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
队列图码解释
aidehua88的专栏
04-10 422
图画得丑了，但是不理解对队列存取数据的动态理解，结合图片以及下面的代码更容理解。//队列类 #pragma once typedef int DATA; class CQue { int m_nHead; int m_nTail; int m_nCount; DATA*m_pHead; public: CQue(int nCount=7) { m_pHead = new DATA...
【万字总结】图解堆算法、链表、栈与队列（多图预警）
weixin_33672109的博客
12-18 352
堆算法 什么是堆 堆（heap），是一类特殊的数据结构的统称。它通常被看作一棵树的数组对象。在队列中，调度程序反复提取队列中的第一个作业并运行，因为实际情况中某些时间较短的任务却可能需要等待很长时间才能开始执行，或者某些不短小、但很重要的作业，同样应当拥有优先权。而堆就是为了解决此类问题而设计的数据结构。 二叉堆是一种特殊的堆...
栈实现队列、队列实现栈
小螺号的博客
06-06 142
栈实现队列 整体思路就是两个栈中的元素相互倒，来实现队列先进先出、后进后出的模式 s1是入栈的，s2是出栈的。 入队列，直接压到s1是就行了 出队列，先把s1中的元素全部出栈压入到s2中，弹出s2中的栈顶元素；再把s2的所有元素全部压回s1中 图解1： 图解2： 图解3： 队列实现栈 q1是专职进出栈的，q2只是个中转站 入栈：直接入队列q1即可 出栈：把q1的除最后一个元素外全部转移到队q2中,然后把刚才剩下q1中的那个元素出队列。之后把q2中的全部元素转移回q1中 图解1： 图解2：
数据结构–队列（Java实现）
01-21
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队...
浅谈C#中堆和栈的区别（附上图解）
09-04
C#中栈是编译期间就分配好的内存空间，因此你的代码中必须就栈的大小有明确的定义；堆是程序运行期间动态分配的内存空间，你可以根据程序的运行情况确定要分配的堆内存的大小
小学生队列队形编排和图解.ppt
09-16
小学生队列队形编排和图解.ppt
图解数据结构（使用Python）——队列
12-20
与堆栈相同，队列也可以由列表和链表来实现。 2.1 队列的列表实现 优点： 使用列表来实现队列的算法较简单 缺点： 列表的大小无法根据队列长度来改变，需要固定大小 #用列表实现队列 max_size = 10 #固定列表大小 ...
图解数据结构——栈(Stack)与队列(Queue)
嵌入式软件实战派
05-29 1146
数据结构 身为程序猿或者攻城狮，你肯定知道数据结构这个东西的。而数据结构却有好几种类型，我简单罗列下： 数组(Array) 栈(Stack) 队列(Queue) 链表(Linked List) 树(Tree) 图(Graph) 堆(Heap) 散列(Hash) 以上，数据结构一般有以下几种常用运算： 检索。检索就是在数据结构里查找满足一定条件的节点。一般是给定一个某字段的值，找具有该字段值的节点。 插.
图解数据结构：栈和队列
Sicimike的博客
10-22 4677
前言 上一篇 图解数据结构：数组和单链表 主要讲解了数组和链表这两种线性结构的特点、区别、时间复杂度分析等。对数组和链表的划分，实际上是物理结构（存储结构）的划分。 物理结构有两种基本的结构：顺序存储结构、链式存储结构。而本篇说讲解的栈和队列属于逻辑结构上的划分。逻辑结构分为线性结构、非线性结构。 线性结构：有且仅有一个开始节点和一个终端节点，每个节点最多只有一个直接前驱和一个直接后继。代表结构...
创建最大堆、最小堆、图解堆排序
ormosia2的博客
11-13 1415
优先级队列和堆 堆的存储方式 使用数组来保存二叉树，将二叉树的层序遍历结果按顺序放入数组中。这种方式只适合保存完全二叉树，因为非完全二叉树会浪费空间。 最大堆 满足任意节点的值都大于其子树中节点的值，叫做最大堆。 向下调整建最大堆： public static void adjustDown(int[] array,int parent,int len) { int child = parent * 2 + 1; //左孩子 while(child < len)
DriverManager和DataSource区别、PreparedStatement和Statement区别
ormosia2的博客
11-18 781
DriverManager和DataSource区别 1、DriverManager类来获取的Connection连接，是无法重复利用的，每次使用完以后释放资源时，通过connection.close()都是关闭物理连接。----->用一次关闭一次 2、DataSource提供连接池的支持。连接池在初始化时将创建一定数量的数据库连接，这些链接是可以重复使用的，每次使用完数据库连接，释放资源调用connection.close()都是将Connection对象回收------->重复使用 三种St
前序、中序、后序、层序遍历及重建二叉树
ormosia2的博客
11-11 645
二叉树 一、概念 一棵二叉树是节点的有限集合，该集合可以为空，也可以是由一个根节点和左子树、右子树组成的二叉树。 二叉树的特点： 每个节点最多有两棵子树，即二叉树的度最大为2 二叉树是有序树，不是指排好序的树，而是二叉树有左右之分 二、二叉树的几种形态 从左到右依次为：空树、只有根节点的二叉树、只有左节点的二叉树、只有右节点的二叉树、带左右节点的二叉树 三、完全二叉树和满二叉树 满二叉树：如果一棵二叉树，它的每一层节点数都达到了该层节点数的最大值，那么这棵树就是一个满二叉树。即一棵满二叉树有n层，那么
继承封装多态
ormosia2的博客
10-27 285
一、封装 封装就是公开代码的对外接口，隐藏具体的实现。使用者不关心内部的具体实现步骤和方法，只要能够使用并操作即可。就像我们生活中的手机、电脑、电视、洗衣机等，我们不关心它的构造和工作原理，只要知道如何操作就可以。 1.封装的意义 保护或者防止代码被破坏 保护成员属性，不让改类以外的程序直接访问修改 隐藏方法细节，只留出开放的方法接口供其它程序使用 对方法实现者：类的成员属性只有本类中的方法才可以直接访问并修改。其它类访问成员属性和方法时，只能通过本类预留的公共方法来访问本类的成员属性和方法。 对方法调
浅析hashMap原理及简单实现
ormosia2的博客
11-20 198
知识补充 hashMap是Map的具体实现类。Map是一个接口类，该类没有继承自Collection，该类中存储的是键值对，并且键唯一，不能重复。 键值对：就是一个唯一的key对应一个值。举个例子：就像学生的学号，每个学生的学号对应一个同学的姓名，学号是唯一的，学生的姓名可以重复。也就是说，键值对中键唯一，一个键对应一个值，但是也可以有多个键对应相同的值。就像学校有多个叫王五的同学，他们的学号唯一，但是对应的姓名都是王五。 注意： Map是一个接口，不能实例化对象。如果要实例化对象只能实例化其实现类 M
回溯算法oj
ormosia2的博客
12-18 181
简单回溯算法oj 回溯算法先画树形图！！！！！ 以下三类题模板基本一样，不同之处只是剪枝的方法。回溯算法剪枝要画出树形图，这样就很清楚哪一步该剪枝，依据其特点剪枝。 模板： void backtrack(parameters) { if(满足条件){ //get one answer record answer; return; } for(解空间树的下一个节点){ backtrack(paramter);
图解数据结构java
最新发布
08-25
Java语言提供了丰富的数据结构库，包括数组、链表、栈、队列、树、图等。我将为你图解一些常见的数据结构及其在Java中的实现。 1. 数组（Array）：数组是一种线性数据结构，它按照顺序存储相同类型的元素。在Java中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值