队列的定义和实现

最新推荐文章于 2024-07-02 01:20:15 发布
最新推荐文章于 2024-07-02 01:20:15 发布
阅读量322 收藏 1
点赞数
文章标签： 数据结构与算法 开发工具 java
原文链接：https://my.oschina.net/rawlins/blog/3101773
版权

队列的定义和实现

前言

  • 语言：Java
  • 环境：IntelliJ IDEA
  • JDK版本：1.8
  • 源码：GitHub

队列的定义

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列的特点：

  • 先进先出（FIFO），插入数据从队尾插入，取出数据从队头取出
  • 无论是数组还是链表实现，通常需要两个变量（指针）来标记队头和队尾

队列的实现

数组实现队列

数组实现队列的几种情况：

数组1-1

数组1-2

数组1-3

数组1-4

由上面四种情况可得到以下信息：

  • 初始值front=rear=-1
  • front指向第一个数据的前面，rear直接指向最后一个数据
  • 判断队列为空的条件是front==rear
  • 判断队列满的条件是rear==maxSize-1
  • 有效数据个数为rear-front
  • 入队时先增加rear，再在rear处插入数据
  • 出队时先增加front，再在front处取出数据
public class ArrayQueue {
    private Integer maxSize = 3;    //队列最大可容纳对象数
    private Integer front = -1;  //始终指向第一个数据之前
    private Integer rear = -1;  //指向最后一个数据
    private Employee[] employeeQueue;   //存放数据的数组
    public ArrayQueue(){
        employeeQueue = new Employee[this.maxSize];
    }
    public ArrayQueue(Integer maxSize){
        this.maxSize = maxSize;
        employeeQueue = new Employee[this.maxSize];
    }

    /**
     *  添加一个数据，添加到尾部，添加成功返回true，失败返回false
     */
    public boolean addEmployee(Employee employee){
        if(this.isFull()){
            return false;
        }
        this.rear++;    //队列添加数据时，将last需要后移
        this.employeeQueue[this.rear] = employee;
        return true;
    }

    /*
     *  获取第一条数据，获取后会从队列中移除
     */
    public Employee getEmployee(){
        if(this.isEmpty()){
            return null;
        }
        this.front++;   //移除数据实际上是将first后移，使其无法访问前面的数组
        return this.employeeQueue[this.front];
    }

    /**
     *  显示第一条数据，仅显示，不会从队列移除
     */
    public Employee showEmployee(){
        if(this.isEmpty()){
            return null;
        }
        return this.employeeQueue[this.front+1];
    }

    /**
     * 队列是否为空
     */
    public boolean isEmpty(){
        return this.front == this.rear;
    }

    /**
     *  队列是否已满
     */
    public boolean isFull(){
        return this.rear == this.maxSize-1;
    }
    /**
     * 将队列的所有数据格式化显示
     */
    public String formatQueue(){
        if(this.isEmpty()){
            return "[]";
        }
        String str = "";
        for(int i = this.front;i<this.rear;i++){
            str += this.employeeQueue[i+1].toString()+"\n";
        }
        return str;
    }
}

优点：

  • 容易理解，便于实现

缺点：

  • 队列容纳的数据数量有限制
  • 为一次性使用的队列，每取出数据，则之前的位置就无法再次使用，如果将该队列插入满数据，再全部取出，那么虽然该队列理论上为空，但实际队列容量已经为0

环形数组实现队列

第一种实现方式： 当front和rear移动至maxSize-1时，将其再移动到数组的开始，以此循环使用

环形数组1-1

环形数组1-2

环形数组1-3

环形数组1-4

由上面四种情况可得到以下信息：

  • 初始值front=rear=0
  • front始终指向第一个数据，rear指向最后一个数据后的空间
  • 判断队列为空的条件是front==rear
  • 判断队列满的条件是(rear+1)%maxSize==front
  • 有效数据个数为(rear+maxSize-front)%maxSize
  • 入队时直接在rear处插入数据，再使rear后移（后移需要取模）
  • 出队时直接取出front处的数据，再使front后移（后移需要取模）
public class CircleArrayQueue1 {
    private Integer maxSize = 3;    //队列最大可容纳对象数
    private Integer front = 0;  //指向第一个数据
    private Integer rear = 0;  //指向最后一个数据的后一个空区域
    private Employee[] employeeQueue;   //存放数据的数组
    public CircleArrayQueue1(){
        employeeQueue = new Employee[this.maxSize];
    }
    public CircleArrayQueue1(Integer maxSize){
        this.maxSize = maxSize;
        employeeQueue = new Employee[this.maxSize];
    }

    /**
     *  添加一个数据，添加到尾部，添加成功返回true，失败返回false
     */
    public boolean addEmployee(Employee employee){
        if(this.isFull()){
            return false;
        }
        this.employeeQueue[this.rear] = employee;
        this.rear = (this.rear+1)%this.maxSize;
        return true;
    }

    /*
     *  获取第一条数据，获取后会从队列中移除
     */
    public Employee getEmployee(){
        if(isEmpty()){
            return null;
        }
        Employee employee = this.employeeQueue[this.front];
        this.front = (this.front+1)%this.maxSize;
        return employee;
    }

    /**
     *  显示第一条数据，仅显示，不会从队列移除
     */
    public Employee showEmployee(){
        if(isEmpty()){
            return null;
        }
        Employee employee = this.employeeQueue[this.front];
        return employee;
    }

    /**
     * 队列是否为空
     */
    public boolean isEmpty(){
        return this.rear == this.front;
    }

    /**
     *  队列是否已满
     */
    public boolean isFull(){
        return (this.rear+1)%this.maxSize == this.front;
    }
    /**
     * 将队列的所有数据格式化显示
     */
    public String formatQueue(){
        if(isEmpty()){
            return "[]";
        }
        String str = "";
        for (int i = this.front;i<this.front+(this.rear + this.maxSize - this.front)%this.maxSize ;i++){
            str += employeeQueue[i%this.maxSize]+"\n";
        }
        return str;
    }
}

优点：

  • 解决了移出数据后空间无法再次使用的问题

缺点：

  • 队列容纳的数据数量有限制
  • 会空出一个位置，即当队列最大容量为6时，实际只能插入5个数据

第二种实现方式： front和rear不再被maxSize限制，只有当使用front和rear时，通过maxSize寻找其在数组中的实际位置

环形数组2-1

环形数组2-2

环形数组2-3

环形数组2-4

由上面四种情况可得到以下信息：

  • 初始值front=rear=-1
  • front始终指向第一个数据的前一个位置，rear指向最后一个数据
  • 判断队列为空的条件是front==rear
  • 判断队列满的条件是rear-front=maxSize
  • 有效数据个数为rear-front
  • 入队时先增加rear，再在rear处插入数据
  • 出队时先增加front，再取出front处的数据
public class CircleArrayQueue2 {
    private Integer maxSize = 3;    //队列最大可容纳对象数
    private Integer front = -1;  //始终指向第一个数据之前
    private Integer rear = -1;  //始终指向最后一个数据
    private Employee[] employeeQueue;   //存放数据的数组
    public CircleArrayQueue2(){
        employeeQueue = new Employee[this.maxSize];
    }
    public CircleArrayQueue2(Integer maxSize){
        this.maxSize = maxSize;
        employeeQueue = new Employee[this.maxSize];
    }

    /**
     *  添加一个数据，添加到尾部，添加成功返回true，失败返回false
     */
    public boolean addEmployee(Employee employee){
        if(this.isFull()){
            return false;
        }
        this.rear++;
        this.employeeQueue[this.rear%this.maxSize] = employee;
        return true;
    }

    /*
     *  获取第一条数据，获取后会从队列中移除
     */
    public Employee getEmployee(){
        if(isEmpty()){
            return null;
        }
        this.front++;
        return this.employeeQueue[this.front%this.maxSize];
    }

    /**
     *  显示第一条数据，仅显示，不会从队列移除
     */
    public Employee showEmployee(){
        if(isEmpty()){
            return null;
        }
        Employee employee = this.employeeQueue[(this.front+1)%this.maxSize];
        return employee;
    }

    /**
     * 队列是否为空
     */
    public boolean isEmpty(){
        return this.rear == this.front;
    }

    /**
     *  队列是否已满
     */
    public boolean isFull(){
        return this.rear-this.front==this.maxSize;
    }
    /**
     * 将队列的所有数据格式化显示
     */
    public String formatQueue(){
        if(isEmpty()){
            return "[]";
        }
        String str = "";
        for (int i = this.front+1;i<=this.rear ;i++){
            str += employeeQueue[i%this.maxSize]+"\n";
        }
        return str;
    }
}

优点：

  • 解决了移出数据后空间无法再次使用的问题
  • 解决了队列会出现空余位置的问题

缺点：

  • 队列容纳的数据数量有限制

链表实现队列

链表实现队列的几种情况：

链表1-1

链表1-2

链表1-3

由上面四种情况可得到以下信息：

  • 初始值last=head
  • head的next指向第一条数据，last直接指向最后一条数据
  • 判断队列为空的条件是head.next==null
  • 有效数据个数为length
  • 入队时将last.next指向新数据，再将last指向新数据
  • 出队时先保存head.next，再将head.next指向取出的数据的next
public class LinkQueue {

    public int length = 0;  //统计有效队列中的数据个数
    private Node head;  //队列的头部
    private Node last;  //队列的尾部

    public LinkQueue(){
        head = new Node();
        this.last = this.head;
    }

    /**
     *  添加一个数据，添加到尾部，添加成功返回true，失败返回false
     */
    public boolean addEmployee(Employee employee){
        Node node = new Node();
        node.data = employee;
        this.last.next = node;
        this.last = node;
        this.length ++;
        return true;
    }

    /*
     *  获取第一条数据，获取后会从队列中移除
     */
    public Employee getEmployee(){
        if(isEmpty()){
            return null;
        }
        Node temp = this.head.next;
        this.head.next = temp.next;
        length --;
        return temp.data;
    }

    /**
     *  显示第一条数据，仅显示，不会从队列移除
     */
    public Employee showEmployee(){
        if(isEmpty()){
            return null;
        }
        Node temp = this.head.next;
        return temp.data;
    }

    /**
     * 队列是否为空
     */
    public boolean isEmpty(){
        return this.head.next == null;
    }

    /**
     * 将队列的所有数据格式化显示
     */
    public String formatQueue(){
        if(isEmpty()){
            return "[]";
        }
        String str = "";
        Node temp = this.head.next;
        while (true){
            str += temp.data.toString() + "\n";
            if(temp.next==null){
                break;
            }
            temp = temp.next;
        }
        return str;
    }
    class Node{
        private Employee data;
        private Node next;
    }
}

优点：

  • 队列容量不受限制
  • 队列不会出现空余位置
  • 利用JVM的垃圾回收机制，可以合理的利用系统资源

转载于:https://my.oschina.net/rawlins/blog/3101773

chenxina7314
关注
队列的定义
人生代码 ---- 公众号
06-07 628
队列跟栈很相似，唯一的区别是：无论是插入还是删除，栈只允许在一端进行操作，插入或者删除都只能靠栈顶指针top;而队列只允许在一端进行插入操作，在另一端进行删除操作，相当于将 top 的工作一分为二，也就是说，队列在插入元素时，只能在一端进行，而删除元素时只能在另一端进行。允许插入的一端成为队尾，允许删除一端的称为对头。队列的对头是出队列的位置，队尾是入队列的位置，这是队列的一大特点。 ...
队列----定义和实现
yjxsdzx的博客
07-11 392
1、队列的定义 队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。     队首(front) ：允许进行删除的一端称为队首。     队尾(rear) ：允许进行插入的一端称为队尾。 　　 例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先
队列的定义和算法的实现
进击的Explorer
08-29 768
与栈相反，队列（queue） 是一种先进先出 （first in first out，缩写为FIFO ）的线性表。它只允许在表的一端进行插入，而在另一端删除元素。在队列中，允许插入的一端叫做队尾 （rear），允许删除的一端则称为 队头（front）。 1、链队列–队列的链式表示和实现 用链表表示的队列简称为链队列 ，一个链队列需要两个分别指示队头和队尾的指针（分别称为头指针和尾指针）才能唯一确定。我们给链队列添加一个头结点，并令头指针指向头结点。因此，空的链队列的判决条件为头指针和尾指针均指向头结点。如下
（超详细）数据结构——“队列”的深度解析
最新发布
qq_58761784的博客
07-02 2284
队列与栈都是线性表，它们的结构也非常类似，都是一头进一头出，那么它们有什么区别吗？答案是有的，虽然它们同为线性表，但是栈的出栈入栈方式为后进先出，而队列的出栈入栈方式为先进先出，具体我们在正文讲解。
队列的定义以及实现
Sun.ME的博客
03-05 2675
队列是只允许在一端进行插入操作，而在另外一端进行删除操作的线性表。 队列是一种先进先出的线性表，简称FIFO，允许插入的一端称之为队尾，允许删除的一端称之为队头。 线性表有顺序存储和链式存储，栈是线性表，队列作为一种特殊的线性表，也同样存在顺序存储结构和链式存储结构。 入队：在队列的末尾追加一个元素，不需要移动任何元素，其时间复杂度为O(1); 出队：队列元素的出列是在队头，即下标为0的位...
循环队列详解及队列的顺序表示和实现
08-31
在提供的代码实现中，定义了一个名为`cir_queue`的结构体，包含了数组`sp_queue_array`用于存储队列元素，以及整型变量`front`和`rear`分别表示队首和队尾的位置。同时，还提供了一系列的函数接口来实现循环队列的...
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
C语言用栈和队列实现的回文检测功能示例
01-20
本文实例讲述了C语言用栈和队列实现的回文功能。分享给大家供大家参考，具体如下： #include #include<malloc>//内存分配头文件 #include<math.h>//在math.h中已定义OVERFLOW的值为3 #define SIZE 100 #...
顺序队列和链式队列的实现
11-08
顺序队列和链式队列的实现 在计算机科学中，队列是一种重要的数据结构，广泛应用于多种领域。在本节中，我们将讨论顺序队列和链式队列的实现。 顺序队列 顺序队列是一种基于数组的队列实现方式。其主要特点是使用...
数据结构入门（五）-队列的定义与实现
Gedeon
02-10 1882
队列的定义队列（queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出（First In First Out)的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端叫做队头。 队列的抽象数据类型C语言中的定义 InitQuene(*Q):初始化操作，建立一个空队列Q DestroyQueue(*Q):若队列Q存在，则销毁它。 ClearQueue
队列的定义与操作
Focus5679的博客
05-09 116
队列的定义与操作-顺序存储typedef int Position; struct QNode { ElementType *Data; /* 存储元素的数组 */ Position Front, Rear; /* 队列的头、尾指针 */ int MaxSize; /* 队列最大容量 */ }; typedef struct QNode *Qu...
队列的概念及其实现
Python 自习室
04-16 392
1.队列的概念 在程序设计中，队列是一种非常有用的数据结构，它和我们平时买票时排的队是类似的，第一个进入队列的人第一个买到票。 队列遵循先进先出（First In First Out）的原则，第一个进入到队列的元素也是第一个出列的元素。入队和出队的过程如下图所示： 在上图中，元素1先于元素 2 入队，所以元素 1 先于元素 2 出队。 2.队列的基本操作 队列支持如下基本操作： 入队：在队尾添加一个元素。 出队：在队首移除一个元素。 判空：判断队列是否为空。 判满：判断队列是否满。 3.队列的操作
数据--第22课 - 队列的定义及实现
weixin_38168760的博客
08-08 74
第22课 - 队列的定义及实现 1. 定义 队列是一种特殊的线性表。 队列仅仅在线性表的两端进行操作。 队头：取出数据元素的一端。 队尾：插入数据元素的一端。 队列允许在中间部位进行操作。 2. 队列的操作 创建队列 销毁队列 清空队列 进队列 出队列 获取队头元素 获取队列长度 3. 示例 （1）LinkQueue main.c #...
队列的定义，实现与基本操作
liyulin90的博客
04-24 2162
定义:一头进另一头出的线性表（排队） 术语：队头，队尾，空队列 基本操作（静态数组式） 定义与初始化 #define Maxsize 10 //定义队列中的最大个数 typedef struct { int data[Maxsize]; int front, rear; //队头指针和队尾指针 }SeQueue; //初始化队列 void InitQueue(SeQueue &Q) { Q.rear = Q.front; //初始化时 队头 队尾指针指...
队列的定义及运用
u012882707的博客
03-23 150
队列简称队，是限制在表的一端进行插入操作，而在表的另一端进行删除操作的线性表。把允许插入数据的一端称为队尾，而把允许删除的一端称为队首或队头。向队列中插入新元素称为进队或入队，新元素进队后就成为新的队尾元素；从队列中删除元素称为出队或离队，元素离队后，其后继元素成为新的队首元素。由于队列的插入和删除各在一端进行，所以每个元素出对的顺序必然就是进队的顺序。 在进行队列的运用时，我们先进行队列的接口...
栈和队列基础与实现
这个课堂练习旨在让学生理解和掌握栈和队列的基本概念，以及它们在实际问题中的应用，包括如何实现和操作这些数据结构。通过链式队列和顺序栈的示例，学生可以深入理解这两种数据结构的工作原理和实现细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值