数据结构-队列

最新推荐文章于 2024-11-10 20:17:28 发布

傻瓜先生DIM

最新推荐文章于 2024-11-10 20:17:28 发布

阅读量148

点赞数 1

分类专栏：数据结构和算法文章标签：数据结构 java

本文链接：https://blog.csdn.net/dimtem/article/details/129109670

版权

数据结构和算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

我们都知道，CPU资源是有限的，任务的处理速度与线程个数斌那个不是线性正相关。相反，过多的线程反而会导致CPU频繁切换，处理性能下降。所以，线程池的大小一般都是综合考虑任务的特点和硬件环境来事先设置的。

当我们向固定大小的线程池中请求一个线程时，如果线程池没有空闲资源了，这个时候线程池是如何处理这个请求？是拒绝请求组还是排队的等候？
这就要跟本文提及的队列有关了。

如何理解队列？

队列的概念很好理解。我们可以把它想象成排队买票，先来的先买，后来的只能排队买，不允许插队。先进者先出，这就是典型的队列。

栈支持两个操作入栈和出栈。队列和栈很相似，最基本的操作也是两个入队（放到一个队列的尾部）和出队（从队列头部取出一个元素）

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

顺序队列和链式队列

数组队列（顺序队列）

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

// 用数组实现的队列
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)。那如何进行优化呢？
实际上我们在出队时可以不用搬移数据。如果没有空闲时间了，我们只需要在入队时，在集中触发一次数据的搬移操作。只需要改造一个入队函数就可以。

   // 入队操作，将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=n的时候会有数据搬移的操作。这样入队操作性就会受到影响。那有没有办法避免数据搬移？那就用到了下面所说的循环队列。

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

我们可以发现，图中这个队列的大小为8，head=4，tail=7。当有一个新元素a要入队时候，我们把他放到下标为7的位置。但这个时候我们并不把tail
更新为8，而是将其在环中后移一位，到下标为0的位置。当再有一个元素b入队时，我们将b放入下标为0位置，然后tail+1更新为1。

通过这样的方式，我们就避免了数据搬移的操作。看起来不难理解，但是循环队列的代码实现要比非循环队列难多了。最关键是确定好队空和队满的条件。
在用数组实现的非循环队列中，队满的判断条件是tailn，队空的判断条件是headtail。那针对于循环队列，队空的判断条件仍然是head==tail，但队满就有些复杂了。

tail=3，head=4，n=8所以队满的时候是（3+1）%8=4。
当队满的时候（tail+1）%n = head。

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;
  }
}