java数据结构与算法之（Queue）队列设计与实现

本是古典 何须时尚 2022-07-14 04:50 229阅读 0赞

【版权申明】转载请注明出处（请尊重原创，博主保留追究权）
http://blog.csdn.net/javazejian/article/details/53375004
出自【zejian的博客】

关联文章:

java数据结构与算法之顺序表与链表设计与实现分析
java数据结构与算法之双链表设计与实现
java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList（带Iterator迭代器与fast-fail机制）
java数据结构与算法之栈（Stack）设计与实现
java数据结构与算法之队列(Queue)设计与实现
java数据结构与算法之递归思维(让我们更通俗地理解递归)
java数据结构与算法之树基本概念及二叉树（BinaryTree）的设计与实现
java数据结构与算法之平衡二叉查找树(AVL树)的设计与实现

  本篇是数据结构与算法的第五篇，本篇我们将来了解一下知识点：

  • 队列的抽象数据类型
  • 顺序队列的设计与实现
  • 链式队列的设计与实现
  • 队列应用的简单举例
  • 优先队列的设置与实现双链表实现

队列的抽象数据类型

  队列同样是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，队列的特点就是先进先出(First In First Out)。我们把向队列中插入元素的过程称为入队(Enqueue)，删除元素的过程称为出队(Dequeue)并把允许入队的一端称为队尾，允许出的的一端称为队头，没有任何元素的队列则称为空队。其一般结构如下：
20161203180332139
关于队列的操作，我们这里主要实现入队，出队，判断空队列和清空队列等操作，声明队列接口Queue（队列抽象数据类型）如下：

  1. package com.zejian.structures.Queue;
  3. /** * Created by zejian on 2016/11/28. * Blog :http://blog.csdn.net/javazejian/article/details/53375004 [原文地址,请尊重原创] * 队列抽象数据类型 */
  4. public interface Queue<T> {
  6.    /** * 返回队列长度 * @return */
  7.    int size();
  9.    /** * 判断队列是否为空 * @return */
  10.    boolean isEmpty();
  12.    /** * data 入队,添加成功返回true,否则返回false,可扩容 * @param data * @return */
  13.    boolean add(T data);
  15.    /** * offer 方法可插入一个元素,这与add 方法不同， * 该方法只能通过抛出未经检查的异常使添加元素失败。 * 而不是出现异常的情况，例如在容量固定（有界）的队列中 * NullPointerException:data==null时抛出 * @param data * @return */
  16.    boolean offer(T data);
  18.    /** * 返回队头元素,不执行删除操作,若队列为空,返回null * @return */
  19.    T peek();
  21.    /** * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  22.    T element();
  24.    /** * 出队,执行删除操作,返回队头元素,若队列为空,返回null * @return */
  25.    T poll();
  27.    /** * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  28.    T remove();
  30.    /** * 清空队列 */
  31.    void clearQueue();
  32. }

下面我们就来分别实现顺序队列和链式队列

顺序队列的设计与实现

  关于顺序队列（底层都是利用数组作为容器）的实现，我们将采用顺序循环队列的结构来实现，在给出实现方案前先来分析一下为什么不直接使用顺序表作为底层容器来实现。实际上采用顺序表实现队列时，入队操作直接执行顺序表尾部插入操作，其时间复杂度为O(1)，出队操作直接执行顺序表头部删除操作，其时间复杂度为O(n)，主要用于移动元素，效率低，既然如此，我们就把出队的时间复杂度降为O(1)即可，为此在顺序表中添加一个头指向下标front和尾指向下标，出队和入队时只要改变front、rear的下标指向取值即可，此时无需移动元素，因此出队的时间复杂度也就变为O(1)。其过程如下图所示

20161203175132047

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

  1. //其中front、rear的下标的取值范围是0~size-1，不会造成假溢出。
  2. front=(front+1)%size;//队头下标
  3. rear=(rear+1)%size;
  1. front为队头元素的下标，rear则指向下一个入队元素的下标
  2. 当front=rear时，我们约定队列为空。
  3. 出队操作改变front下标指向，入队操作改变rear下标指向，size代表队列容量。
  4. 约定队列满的条件为front=(rear+1)%size,注意此时队列中仍有一个空的位置，此处留一个空位主要用于避免与队列空的条件front=rear相同。

  5. 队列内部的数组可扩容，并按照原来队列的次序复制元素数组
    了解了队列的实现规则后，我们重点分析一下入队add方法和出队poll方法，其中入队add方法实现如下：

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

    1.  //判断是否满队
    2.  if (this.front==(this.rear+1)%this.elementData.length){
    3.      ensureCapacity(elementData.length*2+1);
    4.  }
    5.  //添加data
    6.  elementData[this.rear]=data;
    7.  //更新rear指向下一个空元素的位置
    8.  this.rear=(this.rear+1)%elementData.length;
    9.  size++;
    10.  return true;

    }

在add方法中我们先通过this.front==(this.rear+1)%this.elementData.length判断队列是否满，在前面我们约定过队列满的条件为front=(rear+1)%size,如果队列满，则先通过ensureCapacity(elementData.length*2+1)扩容，该方法实现如下：

  1. /** * 扩容的方法 * @param capacity */
  2.  public void ensureCapacity(int capacity) {
  3.      //如果需要拓展的容量比现在数组的容量还小,则无需扩容
  4.      if (capacity<size)
  5.          return;
  7.      T[] old = elementData;
  8.      elementData= (T[]) new Object[capacity];
  9.      int j=0;
  10.      //复制元素
  11.      for (int i=this.front; i!=this.rear ; i=(i+1)%old.length) {
  12.          elementData[j++] = old[i];
  13.      }
  14.      //恢复front,rear指向
  15.      this.front=0;
  16.      this.rear=j;
  17.  }

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

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

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

  1. package com.zejian.structures.Queue;
  3. import java.io.Serializable;
  4. import java.util.NoSuchElementException;
  6. /** * Created by zejian on 2016/11/28. * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创] * 顺序队列的实现 */
  7. public class SeqQueue<T> implements Queue<T> ,Serializable { 
  10.     private static final long serialVersionUID = -1664818681270068094L;
  11.     private static final int  DEFAULT_SIZE = 10;
  13.     private T elementData[];
  15.     private int front,rear;
  17.     private int size;
  20.     public SeqQueue(){
  21.         elementData= (T[]) new Object[DEFAULT_SIZE];
  22.         front=rear=0;
  23.     }
  25.     public SeqQueue(int capacity){
  26.         elementData= (T[]) new Object[capacity];
  27.         front=rear=0;
  28.     }
  30.     @Override
  31.     public int size() {
  32. // LinkedList
  33.         return size;
  34.     }
  36.     @Override
  37.     public boolean isEmpty() {
  38.         return front==rear;
  39.     }
  41.     /** * data 入队,添加成功返回true,否则返回false,可扩容 * @param data * @return */
  42.     @Override
  43.     public boolean add(T data) {
  44.         //判断是否满队
  45.         if (this.front==(this.rear+1)%this.elementData.length){
  46.             ensureCapacity(elementData.length*2+1);
  47.         }
  48.         //添加data
  49.         elementData[this.rear]=data;
  50.         //更新rear指向下一个空元素的位置
  51.         this.rear=(this.rear+1)%elementData.length;
  52.         size++;
  53.         return true;
  54.     }
  56.     /** * offer 方法可插入一个元素,这与add 方法不同， * 该方法只能通过抛出未经检查的异常使添加元素失败。 * 而不是出现异常的情况，例如在容量固定（有界）的队列中 * NullPointerException:data==null时抛出 * IllegalArgumentException:队满,使用该方法可以使Queue的容量固定 * @param data * @return */
  57.     @Override
  58.     public boolean offer(T data) {
  59.         if (data==null)
  60.             throw new NullPointerException("The data can\'t be null");
  61.         //队满抛出异常
  62.         if (this.front==(this.rear+1)%this.elementData.length){
  63.             throw new IllegalArgumentException("The capacity of SeqQueue has reached its maximum");
  64.         }
  66.         //添加data
  67.         elementData[this.rear]=data;
  68.         //更新rear指向下一个空元素的位置
  69.         this.rear=(this.rear+1)%elementData.length;
  70.         size++;
  72.         return true;
  73.     }
  75.     /** * 返回队头元素,不执行删除操作,若队列为空,返回null * @return */
  76.     @Override
  77.     public T peek() {
  78.         return elementData[front];
  79.     }
  81.     /** * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  82.     @Override
  83.     public T element() {
  84.         if(isEmpty()){
  85.             throw new NoSuchElementException("The SeqQueue is empty");
  86.         }
  87.         return peek();
  88.     }
  90.     /** * 出队,执行删除操作,返回队头元素,若队列为空,返回null * @return */
  91.     @Override
  92.     public T poll() {
  93.         T temp=this.elementData[this.front];
  94.         this.front=(this.front+1)%this.elementData.length;
  95.         size--;
  96.         return temp;
  97.     }
  99.     /** * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  100.     @Override
  101.     public T remove() {
  102.         if (isEmpty()){
  103.             throw new NoSuchElementException("The SeqQueue is empty");
  104.         }
  105.         return poll();
  106.     }
  108.     @Override
  109.     public void clearQueue() {
  110.         for (int i=this.front; i!=this.rear ; i=(i+1)%elementData.length) {
  111.             elementData[i] = null;
  112.         }
  113.         //复位
  114.         this.front=this.rear=0;
  115.         size=0;
  116.     }
  118.     /** * 扩容的方法 * @param capacity */
  119.     public void ensureCapacity(int capacity) {
  120.         //如果需要拓展的容量比现在数组的容量还小,则无需扩容
  121.         if (capacity<size)
  122.             return;
  124.         T[] old = elementData;
  125.         elementData= (T[]) new Object[capacity];
  126.         int j=0;
  127.         //复制元素
  128.         for (int i=this.front; i!=this.rear ; i=(i+1)%old.length) {
  129.             elementData[j++] = old[i];
  130.         }
  131.         //恢复front,rear指向
  132.         this.front=0;
  133.         this.rear=j;
  134.     }
  135. }

链式队列的设计与实现

  分析完顺序队列，我们接着看看链式队列的设计与实现，对于链式队列，将使用带头指针front和尾指针rear的单链表实现，front直接指向队头的第一个元素，rear指向队尾的最后一个元素，其结构如下：
20161203224607173
  之所以选择单链表（带头尾指针）而不采用循环双链表或者双链表主要是双链表的空间开销（空间复杂度，多前继指针）相对单链表来说大了不少，而单链表只要新增头指针和尾指针就可以轻松实现常数时间内（时间复杂度为O(1)）访问头尾结点。下面我们来看看如何设计链式队列：

  1. 以上述的图为例分别设置front和rear指向队头结点和队尾结点，使用单链表的头尾访问时间复杂度为O(1)。
  2. 设置初始化空队列，使用front=rear=null，并且约定条件front==null&&rear==null成立时，队列为空。
  3. 出队操作时，若队列不为空获取队头结点元素，并删除队头结点元素，更新front指针的指向为front=front.next
  4. 入队操作时，使插入元素的结点在rear之后并更新rear指针指向新插入元素。
  5. 当第一个元素入队或者最后一个元素出队时，同时更新front指针和rear指针的指向。
    这一系列过程如下图所示：

链式队列

ok~，关于链式队列的设计都分析完，至于实现就比较简单了，和之前分析过的单链表区别不大，因此这里我们直接给出实现代码即可：

  1. package com.zejian.structures.Queue;
  3. import com.zejian.structures.LinkedList.singleLinked.Node;
  5. import java.io.Serializable;
  6. import java.util.*;
  8. /** * Created by zejian on 2016/11/28. * Blog : http://blog.csdn.net/javazejian/article/details/53375004 [原文地址,请尊重原创] * 链式队列的实现 */
  9. public class LinkedQueue<T> implements Queue<T> ,Serializable{ 
  10.     private static final long serialVersionUID = 1406881264853111039L;
  11.     /** * 指向队头和队尾的结点 * front==null&&rear==null时,队列为空 */
  12.     private Node<T> front,rear;
  14.     private int size;
  15.     /** * 用于控制最大容量,默认128,offer方法使用 */
  16.     private int maxSize=128;
  18.     public LinkedQueue(){
  19.         //初始化队列
  20.         this.front=this.rear=null;
  21.     }
  23.     @Override
  24.     public int size() {
  25.         return size;
  26.     }
  28.     public void setMaxSize(int maxSize){
  29.         this.maxSize=maxSize;
  30.     }
  32.     @Override
  33.     public boolean isEmpty() {
  34.         return front==null&&rear==null;
  35.     }
  37.     /** * data 入队,添加成功返回true,否则返回false,可扩容 * @param data * @return */
  38.     @Override
  39.     public boolean add(T data) {
  40.         Node<T> q=new Node<>(data,null);
  41.         if (this.front==null) {
  42.    //空队列插入
  43.             this.front = q;
  44.         } else {
  45.    //非空队列,尾部插入
  46.             this.rear.next=q;
  47.         }
  48.         this.rear=q;
  49.         size++;
  50.         return true;
  51.     }
  53.     /** * offer 方法可插入一个元素,这与add 方法不同， * 该方法只能通过抛出未经检查的异常使添加元素失败。 * 而不是出现异常的情况，例如在容量固定（有界）的队列中 * NullPointerException:data==null时抛出 * IllegalArgumentException:队满,使用该方法可以使Queue的容量固定 * @param data * @return */
  54.     @Override
  55.     public boolean offer(T data) {
  56.         if (data==null)
  57.             throw new NullPointerException("The data can\'t be null");
  58.         if (size>=maxSize)
  59.             throw new IllegalArgumentException("The capacity of LinkedQueue has reached its maxSize:128");
  61.         Node<T> q=new Node<>(data,null);
  62.         if (this.front==null) {
  63.    //空队列插入
  64.             this.front = q;
  65.         } else {
  66.    //非空队列,尾部插入
  67.             this.rear.next=q;
  68.         }
  69.         this.rear=q;
  70.         size++;
  71.         return false;
  72.     }
  74.     /** * 返回队头元素,不执行删除操作,若队列为空,返回null * @return */
  75.     @Override
  76.     public T peek() {
  77.         return this.isEmpty()? null:this.front.data;
  78.     }
  80.     /** * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  81.     @Override
  82.     public T element() {
  83.         if(isEmpty()){
  84.             throw new NoSuchElementException("The LinkedQueue is empty");
  85.         }
  86.         return this.front.data;
  87.     }
  89.     /** * 出队,执行删除操作,返回队头元素,若队列为空,返回null * @return */
  90.     @Override
  91.     public T poll() {
  92.         if (this.isEmpty())
  93.             return null;
  94.         T x=this.front.data;
  95.         this.front=this.front.next;
  96.         if (this.front==null)
  97.             this.rear=null;
  98.         size--;
  99.         return x;
  100.     }
  102.     /** * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  103.     @Override
  104.     public T remove() {
  105.         if (isEmpty()){
  106.             throw new NoSuchElementException("The LinkedQueue is empty");
  107.         }
  108.         T x=this.front.data;
  109.         this.front=this.front.next;
  110.         if (this.front==null)
  111.             this.rear=null;
  112.         size--;
  113.         return x;
  114.     }
  116.     @Override
  117.     public void clearQueue() {
  118.         this.front= this.rear=null;
  119.         size=0;
  120.     }
  121. }

队列应用的简单举例

  1. 模拟现实世界中的队列，如售票柜台的队列以及其他先到先服务的场景。
  2. 计算客户在呼叫中心等待的时间。
  3. 异步数据的传输（文件输入输出、管道、嵌套字）。
  4. 操作系统中的优先级任务执行。
  5. 短信群体发送 应用的发布订阅模式

优先队列的设置与实现（双链表实现）

  了解完循环顺序队列和链式队列的实现后，我们最后再来了解一个特殊的队列，也就是优先队列，在某些情况下，有些应用系统要求不仅需要按照“先来先服务”的原则进行，而且还需按照任务的重要或紧急程度进行排队处理，此时就需要使用到优先队列。比如在操作系统中进行进程调度管理，每个进程都具备一个优先级值以表示进程的紧急程度，优先级高的进行先执行，同等级进程按照先进先出的原则排队处理，此时操作系统使用的便是优先队列管理和调度进程。
  优先级队列也是一种特殊的数据结构，队列中的每个元素都有一个优先级，若每次出队的是具有最高优先级的元素，则称为降序优先级队列(总是先删除最大的元素)。若每次出队的是值最小的元素，则称为升序优先级队列(总是先删除最小的元素)，通常情况下我们所说的优先队列，一般是指降序优先级队列。关于优先队列的实现，可以使用有序数组或者有序链表，也可以使用二叉树（二叉堆）实现，这里我们仅给出有序链表的简单实现方案。而二叉树的实现，留着后面我们分析完树时再给出。好~，这里使用之前分析过的MyLikedList作为基底，实现一个排序的SortLinkedList继承自MyLinkedList，这里需要注意的是排序链表中的T类型必须是实现了Comparable接口的类型，在SortLinkedList中主要重写添加的add方法，插入逻辑是，通过比较元素的大小加入，而非简单下标或尾部插入，其实现如下：

  1. package com.zejian.structures.LinkedList.MyCollection;
  3. import java.io.Serializable;
  4. import java.util.Iterator;
  5. import java.util.ListIterator;
  7. /** * Created by zejian on 2016/12/3. * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创] * 排序list的简单实现 */
  8. public class SortMyLinkedList<T extends Comparable<? extends T>> extends MylinkeList<T> implements Serializable { 
  10.     private static final long serialVersionUID = -4783131709270334156L;
  12.     @Override
  13.     public boolean add(T data) {
  14.         if(data==null)
  15.             throw new NullPointerException("data can\'t be null");
  17.         Comparable cmp =data;//这里需要转一下类型,否则idea编辑器上检验不通过.
  19.         if(this.isEmpty() || cmp.compareTo(this.last.prev.data) > 0){
  20.              return super.add(data);//直接尾部添加,last不带数据的尾结点
  21.         }
  23.         Node<T> p=this.first.next;
  24.         //查找插入点
  25.         while (p!=null&&cmp.compareTo(p.data)>0)
  26.             p=p.next;
  28.         Node<T> q=new Node<>(p.prev,data,p);
  29.         p.prev.next=q;
  30.         p.prev=q;
  32.         size++;
  33.         //记录修改
  34.         modCount++;
  36.         return true;
  37.     }
  39.     /** * 不根据下标插入,只根据比较大小插入 * @param index * @param data */
  40.     @Override
  41.     public void add(int index, T data) {
  42.         this.add(data);
  43.     }
  46.     /** * 未实现 * @param index * @return */
  47.     @Override
  48.     public ListIterator<T> listIterator(int index) {
  49.         return null;
  50.     }
  52.     /** * 未实现 * @return */
  53.     @Override
  54.     public Iterator<T> iterator() {
  55.         return null;
  56.     }
  58.     //测试
  59.     public static void main(String[] args){
  60.         SortMyLinkedList<Integer> list=new SortMyLinkedList<>();
  61.         list.add(50);
  62.         list.add(40);
  63.         list.add(80);
  64.         list.add(20);
  65.         print(list);
  66.     }
  68.     public static void print(SortMyLinkedList mylinkeList){
  69.         for (int i=0;i<mylinkeList.size();i++) {
  70.             System.out.println("i->"+mylinkeList.get(i));
  71.         }
  72.     }
  73. }

接着以SortMyLinkedList为基底实现优先队列PriorityQueue，实现源码如下，实现比较简单，感觉没啥好说的：

  1. package com.zejian.structures.Queue;
  3. import com.zejian.structures.LinkedList.MyCollection.SortMyLinkedList;
  5. import java.io.Serializable;
  6. import java.util.NoSuchElementException;
  8. /** * Created by zejian on 2016/11/30. * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创] * 优先队列的简单实现,采用排序双链表,T必须实现Comparable接口 */
  9. public class PriorityQueue<T extends Comparable<? extends T>> implements Queue<T> ,Serializable { 
  11.     private static final long serialVersionUID = 8050142086009260625L;
  13.     private SortMyLinkedList<T> list;//排序循环双链表
  15.     private boolean asc;//true表示升序,false表示降序
  17.     /** * 用于控制最大容量,默认128,offer方法使用 */
  18.     private int maxSize=128;
  19.     /** * 初始化队列 * @param asc */
  20.     public PriorityQueue(boolean asc){
  21.         this.list=new SortMyLinkedList<>();
  22.         this.asc=asc;//默认升序
  23.     }
  25.     public int getMaxSize() {
  26.         return maxSize;
  27.     }
  29.     public void setMaxSize(int maxSize) {
  30.         this.maxSize = maxSize;
  31.     }
  33.     @Override
  34.     public int size() {
  35.         return list.size();
  36.     }
  38.     @Override
  39.     public boolean isEmpty() {
  40.         return list.isEmpty();
  41.     }
  43.     /** * data 入队,添加成功返回true,否则返回false * @param data * @return */
  44.     @Override
  45.     public boolean add(T data) {
  46.         return list.add(data);
  47.     }
  49.     /** * offer 方法可插入一个元素,这与add 方法不同， * 该方法只能通过抛出未经检查的异常使添加元素失败。 * 而不是出现异常的情况，例如在容量固定（有界）的队列中 * NullPointerException:data==null时抛出 * IllegalArgumentException:队满,使用该方法可以使Queue的容量固定 * @param data * @return */
  50.     @Override
  51.     public boolean offer(T data) {
  52.         if (data==null)
  53.             throw new NullPointerException("The data can\'t be null");
  54.         if (list.size()>=maxSize)
  55.             throw new IllegalArgumentException("The capacity of PriorityQueue has reached its maxSize:128");
  57.         return add(data);
  58.     }
  60.     /** * 返回队头元素,不执行删除操作,若队列为空,返回null * @return */
  61.     @Override
  62.     public T peek() {
  63.         if(isEmpty()){
  64.             return null;
  65.         }
  66.         return this.asc ? this.list.get(0):this.list.get(size()-1);
  67.     }
  69.     /** * 返回队头元素,不执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  70.     @Override
  71.     public T element() {
  72.         if(isEmpty()){
  73.             throw new NoSuchElementException("The PriorityQueue is empty");
  74.         }
  75.         return peek();
  76.     }
  78.     /** * 出队,执行删除操作,返回队头元素,若队列为空,返回null * @return */
  79.     @Override
  80.     public T poll() {
  81.         if(isEmpty()){
  82.             return null;
  83.         }
  84.         return this.asc ? this.list.remove(0): this.list.remove(list.size()-1);
  85.     }
  87.     /** * 出队,执行删除操作,若队列为空,抛出异常:NoSuchElementException * @return */
  88.     @Override
  89.     public T remove() {
  90.         if (isEmpty()){
  91.             throw new NoSuchElementException("The PriorityQueue is empty");
  92.         }
  93.         return poll();
  94.     }
  96.     @Override
  97.     public void clearQueue() {
  98.         this.list.clear();
  99.     }
  101.     //测试
  102.     public static void main(String[] args){
  103.         PriorityQueue<Process> priorityQueue=new PriorityQueue<>(false);
  105.         System.out.println("初始化队列");
  106.         priorityQueue.add(new Process("进程1",10));
  107.         priorityQueue.add(new Process("进程2",1));
  108.         priorityQueue.add(new Process("进程3",8));
  109.         priorityQueue.add(new Process("进程4",3));
  110.         priorityQueue.add(new Process("进程5"));
  111.         System.out.println("队列中的进程执行优先级:");
  112.         while (!priorityQueue.isEmpty()){
  113.             System.out.println("process:"+priorityQueue.poll().toString());
  114.         }
  116.     }
  118. }

ok~，就到这吧，下一篇我们聊聊递归算法，源码下载地址：
github源码下载（含文章列表，持续更新）

发表评论

表情：
评论列表 （有 0 条评论，229人围观）

还没有评论，来说两句吧...

相关阅读

    相关 数据结构与算法之队列

    前言 队列是一个有序的线性列表，可以用数组或链表来实现，遵循先进先出、后进后出的原则。 队列只能从列表的一端进行入队另一端进行出队操作。 队列有两种存储数据的形式：

    超、凢脫俗超、凢脫俗/ 0 赞/ 408 阅读