数据结构与算法-队列

最新推荐文章于 2025-10-17 09:23:42 发布

原创最新推荐文章于 2025-10-17 09:23:42 发布 · 184 阅读

0 ·

CC 4.0 BY-SA版权

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

26 篇文章

订阅专栏

队列

特性

操作特性：

队列也是一种操作受限的线性表，只允许在一端插入和删除数据。

跟栈一样，队列也可以使用数据来实现，还可以使用链表来实现。

使用数组实现的队列叫做顺序队列，使用链表实现的队列叫做链式队列。

顺序队列

/**
* use array implement queue
*
* @author liujun
* @version 0.0.1
* @date 2019/08/23
*/
public class MyArrayQueue {

private int[] array;

/** max queue size */
private final int MaxArraySize;

private int size;

private int head;

private int tail;

public MyArrayQueueOne(int maxArraySize) {
    this.MaxArraySize = maxArraySize;
    this.array = new int[maxArraySize];
    this.head = 0;
    this.tail = 0;
}

public void enqueue(int value) {
    if (tail < MaxArraySize) {
      array[tail] = value;
      tail++;
      size++;
    } else {
      throw new IndexOutOfBoundsException("queue full");
    }
}

public int size() {
    return size;
}

public boolean isfull() {
    return size == MaxArraySize;
}

public int dequeue() {

    int getValue = -1;

    if (head < tail) {
      getValue = array[head];

      for (int i = 1; i < tail; i++) {
        array[i - 1] = array[i];
      }
      tail = tail - 1;
      size--;
    }

    return getValue;
}
}

这是一个基本的队列实现，但存在着问题，那就是数组空间连续性的问题，在每次操作的，会进行数据的所有数据的一次搬移操作。

每次有一个数据从队列中取出，就会触发一次数据的搬移，浪费严重。针对此问题，可采用集中式的触发。即当队列中的数据被填满了，才触发一次数据搬移操作。在队列还没有被填满之前，不进行数据的搬移操作。

public void enqueue(int value) {
if (tail <= MaxArraySize) {

    //如果空间已经被占用，则触发一次搬移操作
    if (tail == MaxArraySize) {
      for (int i = head; i < tail; i++) {
        array[i - head] = array[i];
      }
      tail = head;
      head = 0;
    }
    //
    if (tail < MaxArraySize) {
      array[tail] = value;
      tail++;
      size++;
    }
} else {
    throw new IndexOutOfBoundsException("queue full");
}
}

循环队列

在顺序队列的实现中，当tail == MaxArraySize 会有数据的搬移操作。必然的会影响到性能，那有没有不搬移数据的实现呢？那这个来看看循环队列的实现思路。

循环队列，类比循环链表，那就是一个首尾相连的数组。

就像一个环一样，队列的添加与删除总不断的这环中往复。

但要想写出没有bug的环境形队列，关键在于确定队空与队满的判定条件。假如队列大小为n，那么，队空的判定条件就是head==tail,那队满的判断条件呢。先来看看图中所画队满时的环形队列

tail =1、head=2 队列大小为8，可(1+1)%8=2

总结规律就是(tail+1)%n == head，这就是环形队列满的判定条件。

再来看看代码实现吧：

/**
* use array implement cycle queue
*
* @author liujun
* @version 0.0.1
* @date 2019/08/25
*/
public class MyCycleQueue {

private final int[] array;

private final int capacity;

private int head;

private int tail;

public MyCycleQueue(int maxSize) {
    this.capacity = maxSize;
    this.array = new int[capacity];
}

public void enqueue(int value) {
    // check cycle is full
    if ((tail + 1) % capacity == head) {
      throw new IndexOutOfBoundsException("queue is full");
    } else {
      array[tail] = value;
      tail = (tail + 1) % capacity;
    }
}

public int dequeue() {
    // check cycle is null
    int getvalue = -1;
    if (head == tail) {
      throw new NegativeArraySizeException("queue is empty");
    } else {
      getvalue = array[head];
      head = (head + 1) % capacity;
    }

    return getvalue;
}
}

链式队列

链式队列的实现.

因为链表只涉及节点的删除与添加操作。没有数据搬移的操作，实现起来也比较简单。但因为链表是内存不连续，对于CPU的缓存不友好。

/**
* use linked implement queue
*
* @author liujun
* @version 0.0.1
* @date 2019/08/23
*/
public class MyLinkedQueue {

class LinkNode {
    private int val;

    private LinkNode next;

    public LinkNode(int valu) {
      this.val = valu;
    }
}

/** max queue size */
private final int MaxQueueSize;

private LinkNode root = new LinkNode(-1);

private LinkNode tail = root;

private int size;

public MyLinkedQueue(int maxQueueSize) {
    this.MaxQueueSize = maxQueueSize;
}

public int size() {
    return size;
}

public boolean isfull() {
    return size == MaxQueueSize;
}

public void enqueue(int value) {

    if (size < MaxQueueSize) {
      LinkNode tmpValue = new LinkNode(value);

      tail.next = tmpValue;
      tail = tmpValue;

      size++;
    }
}

public int dequeue() {

    int getvalue = -1;
    if (size > 0) {
      LinkNode linkNode = root.next;
      getvalue = linkNode.val;

      root.next = linkNode.next;

      if (null == root.next) {
        tail = root;
      }

      size--;
    }

    return getvalue;
}
}