数据结构与算法_05_队列

数据结构与算法，系列文章传送地址，请点击本链接。

一、如何理解“队列”？

        队列这个概念非常好理解。你可以把它想象成排队买票，先来的先买，后来的人只能站末尾，不允许插队。先进者先出，这就是典型的“队列”。

        我们知道，栈只支持两个基本操作：入栈 push()和出栈 pop()。队列跟栈非常相似，支持的操作也很有限，最基本的操作也是两个：入队 enqueue()，放一个数据到队列尾部；出队 dequeue()，从队列头部取一个元素。

队列跟栈一样，也是一种操作受限的线性表数据结构。

二、顺序队列和链式队列

跟栈一样，队列可以用数组来实现，也可以用链表来实现。用数组实现的栈叫作顺序栈，用链表实现的栈叫作链式栈。同样，用数组实现的队列叫作顺序队列，用链表实现的队列叫作链式队列。

数组实现队列代码：

// 用数组实现的队列 public class ArrayQueue {   // 数组：items，数组大小：n   private String[] items;   private int n = 0;   // head表示队头下标，tail表示队尾下标   private int head = 0;   private int tail = 0;   // 申请一个大小为capacity的数组   public ArrayQueue(int capacity) {     items = new String[capacity];     n = capacity;   }   // 入队   public boolean enqueue(String item) {     // 如果tail == n 表示队列已经满了     if (tail == n) return false;     items[tail] = item;     ++tail;     return true;   }   // 出队   public String dequeue() {     // 如果head == tail 表示队列为空     if (head == tail) return null;     // 为了让其他语言的同学看的更加明确，把--操作放到单独一行来写了     String ret = items[head];     ++head;     return ret;   } }

对于栈来说，我们只需要一个栈顶指针就可以了。但是队列需要两个指针：一个是 head 指针，指向队头；一个是 tail 指针，指向队尾。

你可以结合下面这张图来理解。当 a、b、c、d 依次入队之后，队列中的 head 指针指向下标为 0 的位置，tail 指针指向下标为 4 的位置。

当我们调用两次出队操作之后，队列中 head 指针指向下标为 2 的位置，tail 指针仍然指向下标为 4 的位置。

你肯定已经发现了，随着不停地进行入队、出队操作，head 和 tail 都会持续往后移动。当 tail 移动到最右边，即使数组中还有空闲空间，也无法继续往队列中添加数据了。这个问题该如何解决呢？你是否还记得，在数组那一节，我们也遇到过类似的问题，就是数组的删除操作会导致数组中的数据不连续。

你还记得我们当时是怎么解决的吗？对，用数据搬移！但是，每次进行出队操作都相当于删除数组下标为 0 的数据，要搬移整个队列中的数据，这样出队操作的时间复杂度就会从原来的 O(1) 变为 O(n)。能不能优化一下呢？

实际上，我们在出队时可以不用搬移数据。如果没有空闲空间了，我们只需要在入队时，再集中触发一次数据的搬移操作。借助这个思想，出队函数 dequeue() 保持不变，我们稍加改造一下入队函数 enqueue() 的实现，就可以轻松解决刚才的问题了。下面是具体的代码：

// 入队操作，将item放入队尾  public boolean enqueue(String item) {  // tail == n表示队列末尾没有空间了  if (tail == n) {  // tail ==n && head==0，表示整个队列都占满了  if (head == 0) return false;  // 数据搬移  for (int i = head; i < tail; ++i) {  items[i-head] = items[i];  }  // 搬移完之后重新更新head和tail  tail -= head;  head = 0;  } items[tail] = item; ++tail; return true; }

从代码中我们看到，当队列的 tail 指针移动到数组的最右边后，如果有新的数据入队，我们可以将 head 到 tail 之间的数据，整体搬移到数组中 0 到 tail-head 的位置。

基于链表实现的队列：

基于链表的实现，我们同样需要两个指针：head 指针和 tail 指针。它们分别指向链表的第一个结点和最后一个结点。如图所示，入队时，tail->next= new_node, tail = tail->next；出队时，head = head->next。

三、循环队列

循环队列，顾名思义，它长得像一个环。原本数组是有头有尾的，是一条直线。现在我们把首尾相连，扳成了一个环。

我们可以发现，图中这个队列的大小为 8，当前 head=4，tail=7。当有一个新的元素 a 入队时，我们放入下标为 7 的位置。但这个时候，我们并不把 tail 更新为 8，而是将其在环中后移一位，到下标为 0 的位置。当再有一个元素 b 入队时，我们将 b 放入下标为 0 的位置，然后 tail 加 1 更新为 1。所以，在 a，b 依次入队之后，循环队列中的元素就变成了下面的样子：

通过这样的方法，我们成功避免了数据搬移操作。看起来不难理解，但是循环队列的代码实现难度要比前面讲的非循环队列难多了。要想写出没有 bug 的循环队列的实现代码，最关键的是，确定好队空和队满的判定条件。

在用数组实现的非循环队列中，队满的判断条件是 tail == n，队空的判断条件是 head == tail。那针对循环队列，如何判断队空和队满呢？

队列为空的判断条件仍然是 head == tail。但队列满的判断条件就稍微有点复杂了。

队满的情况，tail=3，head=4，n=8，所以总结一下规律就是：(3+1)%8=4。多画几张队满的图，你就会发现，当队满时，(tail+1)%n=head。

你有没有发现，当队列满时，图中的 tail 指向的位置实际上是没有存储数据的。所以，循环队列会浪费一个数组的存储空间。

示例代码：

public class CircularQueue {   // 数组：items，数组大小：n   private String[] items;   private int n = 0;   // head表示队头下标，tail表示队尾下标   private int head = 0;   private int tail = 0;   // 申请一个大小为capacity的数组   public CircularQueue(int capacity) {     items = new String[capacity];     n = capacity;   }   // 入队   public boolean enqueue(String item) {     // 队列满了     if ((tail + 1) % n == head) return false;     items[tail] = item;     tail = (tail + 1) % n;     return true;   }   // 出队   public String dequeue() {     // 如果head == tail 表示队列为空     if (head == tail) return null;     String ret = items[head];     head = (head + 1) % n;     return ret;   } }

四、阻塞队列和并发队列

前面讲的内容理论比较多，看起来很难跟实际的项目开发扯上关系。确实，队列这种数据结构很基础，平时的业务开发不大可能从零实现一个队列，甚至都不会直接用到。而一些具有特殊特性的队列应用却比较广泛，比如阻塞队列和并发队列。

阻塞队列其实就是在队列基础上增加了阻塞操作。简单来说，就是在队列为空的时候，从队头取数据会被阻塞。因为此时还没有数据可取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲位置后再插入数据，然后再返回。

基于阻塞队列，我们还可以通过协调“生产者”和“消费者”的个数，来提高数据的处理效率。比如前面的例子，我们可以多配置几个“消费者”，来应对一个“生产者”。

线程安全的队列我们叫作并发队列。最简单直接的实现方式是直接在 enqueue()、dequeue() 方法上加锁，但是锁粒度大并发度会比较低，同一时刻仅允许一个存或者取操作。实际上，基于数组的循环队列，利用 CAS 原子操作，可以实现非常高效的并发队列。这也是循环队列比链式队列应用更加广泛的原因。

五、双端队列

一、Queue和Deque异同介绍

我们知道，Queue是队列，只能一头进，另一头出。

如果把条件放松一下，允许两头都进，两头都出，这种队列叫双端队列（Double Ended Queue），学名Deque。

Java集合提供了接口Deque来实现一个双端队列，它的功能是：

既可以添加到队尾，也可以添加到队首；

既可以从队首获取，又可以从队尾获取。

首先我们比较下Queue和Deque出队和入队的方法：

注：这里解释先为什么Queue或者Deque都有两种方法，它们有什么区别？

1、add()和offer()区别:

add()和offer()都是向队列中添加一个元素。一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。因此就可以在程序中进行有效的判断！

2、poll()和remove()区别：

remove() 和 poll() 方法都是从队列中删除第一个元素。如果队列元素为空，调用remove() 的行为与 Collection 接口的版本相似会抛出异常，但是新的 poll() 方法在用空集合调用时只是返回 null。因此新的方法更适合容易出现异常条件的情况。

3、element() 和 peek()区别：

element() 和 peek() 用于在队列的头部查询元素。与 remove() 方法类似，在队列为空时， element() 抛出一个异常，而 peek() 返回 null。

上面介绍的是Queue的两中方法，Deque也是相同的就不介绍了。

二、Deque作为队列和堆栈的介绍

我们知道Queue的数据结构是一个队列，即：FIFO(先进先出)。从队尾添加元素，从对头删除元素。Deque也有等效的方法作为一个FIFO队列，具体方法如下：

Deque(双端队列)也可以用作LIFO（后进先出）堆栈（也就是栈），应优先使用此接口而不是遗留 Stack类。在将双端队列用作堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于Deque 方法，如下表所示：

总结：

1、Queue只能从队尾插入，从对头删除。

2、Deque对头队尾都可以进行插入和删除。

3、Deque根据不同的插入和删除方法可以实现队列和堆栈（也就是栈）这两种数据结构。

声明：文章内容是极客时间专栏学习的学习笔记，会做简化或调整，欢迎大家留言和评论。

数据结构与算法，系列文章传送地址，请点击本链接。https://blog.csdn.net/wanghaiping1993/article/details/125092448