队列queue(待续....)

最新推荐文章于 2021-10-11 14:20:42 发布
最新推荐文章于 2021-10-11 14:20:42 发布
阅读量226 收藏
点赞数
分类专栏： 日记 文章标签： 队列的源码解析 队列的基本使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ke_zhang_123/article/details/77963877
版权

队列(queue):
what(什么是队列)
队列同样是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，队列的特点就是先进先出(First In First Out)。我们把向队列中插入元素的过程称为入队(Enqueue)，删除元素的过程称为出队(Dequeue)并把允许入队的一端称为队尾，允许出的的一端称为队头，没有任何元素的队列则称为空队。其一般结构如下：
这里写图片描述
package com.zejian.structures.Queue;

/**
* Created by zejian on 2016/11/28.
* Blog :http://blog.csdn.net/javazejian/article/details/53375004 [原文地址,请尊重原创]
* 队列抽象数据类型
*/
public interface Queue<T> {

   /**
    * 返回队列长度
    * @return
    */
   int size();

   /**
    * 判断队列是否为空
    * @return
    */
   boolean isEmpty();

   /**
    * data 入队,添加成功返回true,否则返回false,可扩容
    * @param data
    * @return
    */
   boolean add(T data);

   /**
    * offer 方法可插入一个元素,这与add 方法不同，
    * 该方法只能通过抛出未经检查的异常使添加元素失败。
    * 而不是出现异常的情况，例如在容量固定（有界）的队列中
    * NullPointerException:data==null时抛出
    * @param data
    * @return
    */
   boolean offer(T data);

   /**
    * 返回队头元素,不执行删除操作,若队列为空,返回null
    * @return
    */
   T peek();

   /**
    * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException
    * @return
    */
   T element();

   /**
    * 出队,执行删除操作,返回队头元素,若队列为空,返回null
    * @return
    */
   T poll();

   /**
    * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException
    * @return
    */
   T remove();

   /**
    * 清空队列
    */
   void clearQueue();
}

顺序队列的实现:
入队操作直接执行顺序表尾部插入操作，其时间复杂度为O(1)，出队操作直接执行顺序表头部删除操作，其时间复杂度为O(n)，主要用于移动元素，效率低，既然如此，我们就把出队的时间复杂度降为O(1)即可，为此在顺序表中添加一个头指向下标front和尾指向下标，出队和入队时只要改变front、rear的下标指向取值即可，此时无需移动元素，因此出队的时间复杂度也就变为O(1)。
这里写图片描述

从图的演示过程，（a）操作时，是空队列此时front和rear都为-1，同时可以发现虽然我们通过给顺序表添加front和rear变量记录下标后使用得出队操作的时间复杂度降为O(1)，但是却出现了另外一个严重的问题，那就是空间浪费，从图中的（d）和（e）操作可以发现，20和30出队后，遗留下来的空间并没有被重新利用，反而是空着，所以导致执行（f）操作时，出现队列已满的假现象，这种假现象我们称之为假溢出，之所以出现这样假溢出的现象是因为顺序表队列的存储单元没有重复利用机制，而解决该问题的最合适的方式就是将顺序队列设计为循环结构，接下来我们就通过循环顺序表来实现顺序队列。
顺序循环队列就是将顺序队列设计为在逻辑结构上收尾相接的循环结构，这样我们就可以重复利用存储单元，其过程如下所示：
简单分析一下：
其中采用循环结构的顺序表，可以循环利用存储单元，因此有如下计算关系(其中size为队列长度)：
//其中front、rear的下标的取值范围是0~size-1，不会造成假溢出。
front=(front+1)%size;//队头下标
rear=(rear+1)%size;

front为队头元素的下标，rear则指向下一个入队元素的下标
当front=rear时，我们约定队列为空。
出队操作改变front下标指向，入队操作改变rear下标指向，size代表队列容量。
约定队列满的条件为front=(rear+1)%size,注意此时队列中仍有一个空的位置，此处留一个空位主要用于避免与队列空的条件front=rear相同。
队列内部的数组可扩容，并按照原来队列的次序复制元素数组
了解了队列的实现规则后，我们重点分析一下入队offer方法和出队poll方法，其中入队add方法实现如下：

/**
  * 扩容的方法
  * @param capacity
  */
 public void ensureCapacity(int capacity) {
     //如果需要拓展的容量比现在数组的容量还小,则无需扩容
     if (capacity<size)
         return;

     T[] old = elementData;
     elementData= (T[]) new Object[capacity];
     int j=0;
     //复制元素
     for (int i=this.front; i!=this.rear ; i=(i+1)%old.length) {
         elementData[j++] = old[i];
     }
     //恢复front,rear指向
     this.front=0;
     this.rear=j;
 }

这个方法比较简单，主要创建一个新容量的数组，并把旧数组中的元素复制到新的数组中，这里唯一的要注意的是，判断旧数组是否复制完成的条件为i!=this.rear，同时循环的自增条件为i=(i+1)%old.length。扩容后直接通过rear添加新元素，最后更新rear指向下一个入队新元素。对于出队操作poll的实现如下：

/**
 * 出队,执行删除操作,返回队头元素,若队列为空,返回null
 * @return
 */
@Override
public T poll() {
    T temp=this.elementData[this.front];
    this.front=(this.front+1)%this.elementData.length;
    size--;
    return temp;
}

出队操作相对简单些，直接存储要删除元素的数据，并更新队头front的值，最后返回删除元素的数据。ok~，关于循环结构的顺序队列，我们就分析到此，最后给出循环顺序队列的实现源码，其他方法比较简单，注释也很清楚
顺序队列源码:

package com.zejian.structures.Queue;

import java.io.Serializable;
import java.util.NoSuchElementException;

/**
 * Created by zejian on 2016/11/28.
 * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
 * 顺序队列的实现
 */
public class SeqQueue<T> implements Queue<T> ,Serializable {


    private static final long serialVersionUID = -1664818681270068094L;
    private static final int  DEFAULT_SIZE = 10;

    private T elementData[];

    private int front,rear;

    private int size;


    public SeqQueue(){
        elementData= (T[]) new Object[DEFAULT_SIZE];
        front=rear=0;
    }

    public SeqQueue(int capacity){
        elementData= (T[]) new Object[capacity];
        front=rear=0;
    }

    @Override
    public int size() {
//        LinkedList
        return size;
    }

    @Override
    public boolean isEmpty() {
        return front==rear;
    }

    /**
     * data 入队,添加成功返回true,否则返回false,可扩容
     * @param data
     * @return
     */
    @Override
    public boolean add(T data) {
        //判断是否满队
        if (this.front==(this.rear+1)%this.elementData.length){
            ensureCapacity(elementData.length*2+1);
        }
        //添加data
        elementData[this.rear]=data;
        //更新rear指向下一个空元素的位置
        this.rear=(this.rear+1)%elementData.length;
        size++;
        return true;
    }

    /**
     * offer 方法可插入一个元素,这与add 方法不同，
     * 该方法只能通过抛出未经检查的异常使添加元素失败。
     * 而不是出现异常的情况，例如在容量固定（有界）的队列中
     * NullPointerException:data==null时抛出
     * IllegalArgumentException:队满,使用该方法可以使Queue的容量固定
     * @param data
     * @return
     */
    @Override
    public boolean offer(T data) {
        if (data==null)
            throw new NullPointerException("The data can\'t be null");
        //队满抛出异常
        if (this.front==(this.rear+1)%this.elementData.length){
            throw new IllegalArgumentException("The capacity of SeqQueue has reached its maximum");
        }

        //添加data
        elementData[this.rear]=data;
        //更新rear指向下一个空元素的位置
        this.rear=(this.rear+1)%elementData.length;
        size++;

        return true;
    }

    /**
     * 返回队头元素,不执行删除操作,若队列为空,返回null
     * @return
     */
    @Override
    public T peek() {
        return elementData[front];
    }

    /**
     * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException
     * @return
     */
    @Override
    public T element() {
        if(isEmpty()){
            throw new NoSuchElementException("The SeqQueue is empty");
        }
        return peek();
    }

    /**
     * 出队,执行删除操作,返回队头元素,若队列为空,返回null
     * @return
     */
    @Override
    public T poll() {
        T temp=this.elementData[this.front];
        this.front=(this.front+1)%this.elementData.length;
        size--;
        return temp;
    }

    /**
     * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException
     * @return
     */
    @Override
    public T remove() {
        if (isEmpty()){
            throw new NoSuchElementException("The SeqQueue is empty");
        }
        return poll();
    }

    @Override
    public void clearQueue() {
        for (int i=this.front; i!=this.rear ; i=(i+1)%elementData.length) {
            elementData[i] = null;
        }
        //复位
        this.front=this.rear=0;
        size=0;
    }

    /**
     * 扩容的方法
     * @param capacity
     */
    public void ensureCapacity(int capacity) {
        //如果需要拓展的容量比现在数组的容量还小,则无需扩容
        if (capacity<size)
            return;

        T[] old = elementData;
        elementData= (T[]) new Object[capacity];
        int j=0;
        //复制元素
        for (int i=this.front; i!=this.rear ; i=(i+1)%old.length) {
            elementData[j++] = old[i];
        }
        //恢复front,rear指向
        this.front=0;
        this.rear=j;
    }
}

链式队列的设计与实现
………..
why(为什么用队列)

how(怎么用)
队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作.(先进先出)
LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

import java.util.LinkedList;
import java.util.Queue;

import org.junit.Before;
import org.junit.Test;

/**
 * 队列测试：实现类使用LinkedList
 * 
 * Queue也有很多其他的实现类，比如java.util.concurrent.LinkedBlockingQueue。
 * LinkedBlockingQueue是一个阻塞的线程安全的队列，底层实现也是使用链式结构。
 */
public class TestQuene {

    // 定义一个队列
    Queue<String> queue;

    @Before
    public void before() {
        // 实例化队列变量
        queue = new LinkedList<String>();

        // add方法向队列中添加元素,返回布尔值，add方法添加失败时会抛异常,不推荐使用
        // queue.add("1");
        // queue.add("2");
        // queue.add("3");
        // queue.add("4");
        // queue.add("5");

        // offer方法向队列中添加元素，返回布尔值
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");

    }

    // poll方法移除队列首个元素并返回，若队列为空，返回null
    @Test
    public void test1() {
        // 弹出元素
        String pollEle = queue.poll(); // 先进先出,弹出了a
        System.out.println(pollEle); // a
        System.out.println(queue); // [b, c, d, e]
    }

    // remove方法移除首个元素并返回,若队列为空,会抛出异常：NoSuchElementException，不推荐使用
    @Test
    public void test2() {
        // 弹出元素
        String remove = queue.remove(); // 先进先出,弹出了a
        System.out.println(remove); // a
        System.out.println(queue); // [b, c, d, e]
    }

    // peek方法返回队列首个元素，但不移除，若队列为空，返回null
    @Test
    public void test3() {
        // 查看首个元素
        String peek = queue.peek(); // 首个元素是a,最先加入
        System.out.println(peek); // a
        System.out.println(queue); // [a, b, c, d, e]
    }

    // element方法返回队列的头元素，但不移除，若队列为空，会抛出异常：NoSuchElementException，不推荐使用
    @Test
    public void test4() {
        // 查看首个元素
        String element = queue.element();
        System.out.println(element); // a
        System.out.println(queue); // [a, b, c, d, e]
    }
}

注意:在这里使用testNG测试

六.RabbitMQ消息队列的基础+实战
qq_44724899的博客
03-25 529
消息队列是应用程序对应用程序通信的一种方法，应用程序通过读写消息队列中的内容来通信。
算法基础入门 - 2.栈、队列、链表
最新发布
zhongziqia的博客
07-01 2144
队列是一种特殊的线性结构，它只许在队列的首部进行删除操作，称为‘出队’，在队列的尾部进行插入操作，称为‘入队’。小明拿出手中第一张牌放在桌上，随后小红也拿出手中第一张牌放在小明刚打出的牌的上面，就这样交替出牌。通过栈可容易地判断一个字符串是否为回文，一个字符串是回文的话，必须是中间对称的，回文字符指正反读均相同的字符序列。链表的每一个结点由两部分组成，左边部分用来存放具体的数值，右边部分用来存储下一个结点的地址。例：head和tail两个整型变量分别用来记录队列的队首和队列的尾部的下一个位置。
顺序循环队列
LQS的博客
03-21 1322
队列的基本概念 队列（简称队）是一种特殊的线性表，队列的数据元素以及数据元素间的逻辑关系和线性表完全相同，差别就是线性表允许在任意位置插入和删除，而队列只允许在一端进行插入操作而在另一端进行删除操作。 队列中允许进行插入操作的一端称为队尾，允许进行删除的一端称为队头。 操作集合 （1）入队列append（obj）：把数据元素插入队尾； （2）出队列delete（）：把队头
队列 - Queue
kayyoo的博客
02-01 7474
一、队列概述 队列，又称为伫列（queue），计算机科学中的一种抽象资料型别，是先进先出（FIFO, First-In-First-Out）的线性表。 在具体应用中通常用链表或者数组来实现。 队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作。 队列的操作方式和堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。 Queue 用大O符号表示的时间复杂度 算法 平均 最差 空间 O(n) O(n) 搜索 O(n) O(n) 插入 O(1) O(1) 删除 O(1)
队列的插入与删除
热门推荐
我是一只懒羊
07-07 1万+
队列是FIFO(先进先出)的线性表。本文实现了入队、出队、读队头元素、置空队和判断队空。供参考。#include&lt;iostream&gt; #include&lt;stdlib.h&gt; using namespace std; const int MaxSize=100; typedef char datatype; typedef struct{ datatype ...
数据结构学习（java版）——队列（Queue，高级队列）
我想做阿信的博客
01-30 208
普通队列 解释高级队列前，先来看普通队列出队： 出队之后，后边所有的元素都要往前移，时间复杂度为O(n)级别，那么，如果我们能避免往前移这个操作，时间复杂度不久是O(1)了吗？ 高级队列 由此设计出了一个更高级的队列： 第一个元素被移除后，把二个元素当作队首，第二个元素被移除后，把三个元素当作队首，这样就避免了所有元素往前移的操作，但是这样前边的位置就空了，空间有浪费。 如果，后边存满，我们往前边空的位置存，这样就可以解决空间浪费问题了。这就是循环队列 怎么实现呢？ 我们只需要标识一下队首和队尾不就可以实
Queue队列实例
haifeng007的博客
08-25 194
import java.util.Queue; import java.util.LinkedList; import com.cs.webTool.bean.UserData; public class Dee { public static void main(String[] args) { Dee.namer(); } p...
239. 滑动窗口最大值(未完待续...）
qq_38748148的博客
01-02 93
一、题目描述 给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回滑动窗口中的最大值。 示例 1： 输入：nums = [1,3,-1,-3,5,3,6,7], k = 3 输出：[3,3,5,5,6,7] 解释： 滑动窗口的位置 最大值 [1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7
数据结构之队列queue
沉默的二毛的博客
12-10 852
C++数据结构之队列queue 与栈相反，队列是一种先进先出（FIFO）的线性表，只允许在表的一端插入，在另一端删除。允许插入的一端叫队尾，允许删除 的一端叫队头。比较典型的例子有日常生活中的排队：银行排序办理业务、地铁排队上车（emmmm，这里假设所有人都遵守秩序）等，当然还有计算机系统的消息队列，操作系统
菜鸟选手谈谈RabbitMQ基本原理！！！(写的不好，勿见怪，不要喷)未完待续......
牧码人-柯大师博客
07-11 364
What MQ??? 关于MQ的前世今生，咱们细谈 MQ全称为Message Queue,消息队列（MQ）是一种应用程序对应用程序的通信方法(官方语言)。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取队列中的消息。(相当于n年前的信差吧！哦还有邮递员啦！) 在下之前用过IBMmq,可是今天偏偏不说这个，毕竟似乎没...
python：双向队列Deque
一名小测试
05-11 567
双向队列是一个线程安全，可以快速从两端添加或者删除元素的数据类型；首尾操作操作的优化，也导致了双向队列付出了一些代价，比如：从队列中间删除元素就会非常的慢 栗子： 首先引包，然后定义一个队列，设置最大长度为10并打印出来 from collections import deque dq = deque(range(10), maxlen=10) print(dq) 运行后的结果如下： deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10) 注释.
数据结构—— 队列基础
m0_59897687的博客
10-11 598
一、队列概述 队列是一种先入先出（FIFO 即 first input first output）的数据结构 在FIFO数据结构中，首先处理添加到队列中的第一个元素 如上图所示 新的元素会被插入在队列的末尾，该操作被称为“入队”（enqueue），即插入（insert）操作 删除元素时只能删除队列的第一个元素，该操作被称为“出队”（dequeue），即删除（delete）操作 二、操作实现 队列数据定义 类型 描述 enqueue(方法) ...
数据结构学习（java版）——队列（Queue，简单队列）
我想做阿信的博客
01-22 321
队列的理解 看到上边的gif了吧，队列整体，就相当与一个管子，而每一个元素就是貂。 队列的基本功能 功能 说明 方法 入队 队列末尾存放一个元素 void enqueue(E) 出队 取出并删除队列第一个元素 E dequeue() 获取第一个元素 取出但不删除队列第一个元素 E getFront() 查看队列大小 返回队列中元素个数 int getSize() 查看队列是否为空 判断元素个数是否为0 boolean isEmpty() 队列实现原理 队列的具体实现是对数
Parallel Scavenge收集器
kekeair的博客
08-02 4993
Parallel Scavenge收集器what(是什么)Parallel Scavenge收集器是Java虚拟机中垃圾收集器的一种。 又称为吞吐量优先收集器,和ParNew收集器类似，是一个新生代收集器。使用复制算法的并行多线程收集器。 而且是并行的多多线程收集器.java1.8默认的收集器.why(为什么使用它)特点: Parallel Scavenge收集器的关注点与其他收集器不同，
TO_DAYS函数 (SQL)
kekeair的博客
11-15 3666
TO_DAYS函数 返回一个天数! 啊哈？什么天数? 从年份0开始的天比如： SELECT TO_DAYS(‘1997-10-07′); 结果  729669就是从0年开始 到1997年10月7号之间的天数PS:注意括号中是字段名的话不要加单引号之类的！
<Context reloadable="true">
kekeair的博客
11-15 2751
为了在开发时，让tomcat能够自动重新加载，我们修改过的代码和配置，需要对Tomcat的context.xml文件进行设置。 在标签中，加上reloadable属性，并且将值设为true<Context reloadable="true"> <!--注意： reloadable设为true，目的是为了方便开发阶段， 它会影响tomcat性能；当在正式部署服务时，需要改成false -
使用sendMail发送邮件
kekeair的博客
09-06 1534
使用sendMail发送邮件1发送邮件必须有邮件服务器,在这里以QQ邮箱服务器为例 设置QQ邮箱支持POP,ICMP协议(百度有设置方式,在这里不再赘述) 2 下载mail.jar(注意版本,此代码示例为1.6版本) http://download.csdn.net/download/u011238841/9926479 3 代码示例 package com.hengc;im
数据的排序及重排序问题(数据变化需要重排)
kekeair的博客
08-16 1510
数据的排序及重排序问题(数据变化需要重排)大家都知道在集合中TreeSet会去除重复数据并对数据进行排序(默认升序,可以使用Comparable接口的CompareTo 方法改变排序方式),但是当排好的数据发生变化时,它能否重新排序呢? 示例如下:public class test { public static void main(String[] args) {
联合索引引发的插入问题
kekeair的博客
11-15 1195
今天遇见一个联合索引引发的插入数据异常的问题,找了好长时间 问题是这样的: 插入字段 crm_id 参数为12333 结果在执行插入的使用crm_id的值变成了12333-12 (ps:crmlc_time的值为12). 问题出在哪呢?看到没联合索引,印象了插入的值修改方案: 由于这张表需要频繁的查询,所以不能删除,就选择了将他们分开做普通索引
queue_.front();
09-02
queue::front() 是 STL 中 queue 的一个成员函数，它返回队列的首元素，但不改变队列中元素的数量。 例如: ``` queue<int> q; q.push(1); q.push(2); cout << q.front() ; // 输出 1 ``` 注意：使用 front() 前请...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值