『数据结构与算法』队列

微信搜索：码农StayUp
主页地址：https://gozhuyinglong.github.io
源码分享：https://github.com/gozhuyinglong/blog-demos

1. 队列（queue）

队列和栈同样，也是一个操做受限制的线性表。不一样的是队列的插入在一端进行，咱们称为队尾（rear）；而删除（取出）在另外一端进行，咱们称为队头（front）。

队列是一个先进先出（FIFO - First In First Out）的有序列表，其操做只有两种：

• 入队（enqueue）：向队尾添加一个元素
• 出队（dequeue）：从队头删除（取出）一个元素

2. 队列的数组实现

如同栈同样，对队列的每一种操做，链表实现或数组实现都给出快速的运行时间。队列的链表实现是简单而直接的，咱们就不过介绍了。下面咱们讨论如何使用数组实现一个队列。

先看下图，咱们须要声明一个数组，并维护两个指针：

• head指针：指向待出列的元素位置
• tail指针：指向待入列的存储位置
  能够看出，到达队尾后没法再添加新的元素，而后前面已出列的位置还空着。

上面问题咱们能够将数组进行首尾相连，造成一个环形数组，即指针到达数组尾部后，从新指向数组头部，以下图所示。

这里须要注意几点：

• 判断空队列能够经过head == tail
• 判断队列满不能再经过head与tail重合，而是须要空出一个存储空间来，即：head == tail + 1。而环形数组须要取模运算，因此正确判断队列满：head == (tail + 1) % capacity。
• 数组真实容量应为：指定容量 + 1

3. 代码实现

下面代码是使用环形数组实现的队列，因此又叫作环形队列。
其容量为：指定容量 + 1，head 与t ail 初始值为0。队列存储元素使用了泛型，因此能够操做你想用的数据类型。下面看具体实现：

public class ArrayQueueDemo {

    public static void main(String[] args) {
        ArrayQueue<Integer> queue = new ArrayQueue<>(5);
        System.out.printf("头指针: %s\t尾指针: %s\t队列大小: %s\t容量: %s\n", queue.head, queue.tail, queue.size(), queue.capacity);
        System.out.println("出队： --> " + queue.get());
        System.out.println("入队：1 --> " + queue.add(1));
        System.out.println("入队：2 --> " + queue.add(2));
        System.out.println("入队：3 --> " + queue.add(3));
        System.out.println("入队：4 --> " + queue.add(4));
        System.out.println("入队：5 --> " + queue.add(5));

        System.out.printf("头指针: %s\t尾指针: %s\t队列大小: %s\t容量: %s\n", queue.head, queue.tail, queue.size(), queue.capacity);
        System.out.println("出队： --> " + queue.get());
        System.out.println("入队：6 --> " + queue.add(6));
        System.out.printf("头指针: %s\t尾指针: %s\t队列大小: %s\t容量: %s\n", queue.head, queue.tail, queue.size(), queue.capacity);
        System.out.println("入队：7 --> " + queue.add(7));
        System.out.println("出队： --> " + queue.get());
        System.out.println("出队： --> " + queue.get());
        System.out.printf("头指针: %s\t尾指针: %s\t队列大小: %s\t容量: %s\n", queue.head, queue.tail, queue.size(), queue.capacity);
        System.out.println("入队：8 --> " + queue.add(8));
        System.out.println("入队：9 --> " + queue.add(9));
        System.out.printf("头指针: %s\t尾指针: %s\t队列大小: %s\t容量: %s\n", queue.head, queue.tail, queue.size(), queue.capacity);
        System.out.println("出队： --> " + queue.get());
        System.out.println("出队： --> " + queue.get());
        System.out.println("出队： --> " + queue.get());
        System.out.println("出队： --> " + queue.get());
        System.out.println("出队： --> " + queue.get());
        System.out.printf("头指针: %s\t尾指针: %s\t队列大小: %s\t容量: %s\n", queue.head, queue.tail, queue.size(), queue.capacity);
        System.out.println("入队：10 --> " + queue.add(10));
        System.out.printf("头指针: %s\t尾指针: %s\t队列大小: %s\t容量: %s\n", queue.head, queue.tail, queue.size(), queue.capacity);
    }


    private static class ArrayQueue<T> {

        private final T[] queue; // 存储队列数据元素
        private final int capacity; // 容量
        private int head = 0; // 头部指针，指向队头元素
        private int tail = 0; // 尾部指针，指向下一个待入队元素的存储位置

        public ArrayQueue(int capacity) {
            this.capacity = capacity + 1; // 环形队列须要空出一个位置，来知足队列满时head与tail不重合
            this.queue = (T[]) new Object[this.capacity];
        }

        /**
         * 向队列添加一个元素
         *
         * @param data
         * @return
         */
        public boolean add(T data) {
            // 队列满，添加失败
            if (isFull()) {
                return false;
            }
            // tail指向下一个待入队元素的存储位置，因此先赋值再让指针加1
            queue[tail] = data;
            // 环形数组须要取模运算
            tail = (tail + 1) % capacity;
            return true;
        }

        /**
         * 从队列中获取一个元素
         *
         * @return
         */
        public T get() {
            if (isEmpty()) {
                return null;
            }
            // head指向头元素位置，因此先取出再让指针加1
            T data = queue[head];
            // 环形数组须要取模运算
            head = (head + 1) % capacity;
            return data;
        }

        /**
         * 当前队列大小
         *
         * @return
         */
        public int size() {
            int size = tail - head;
            if (size < 0) {
                size += capacity;
            }
            return size;
        }

        /**
         * 队列是否为空：当tail与head指向同一位置时，表示队列为空
         *
         * @return
         */
        public boolean isEmpty() {
            return tail == head;
        }

        /**
         * 队列是否已满：由于预留了一个位置，因此tail须要加1；环形队列须要取模运算
         *
         * @return
         */
        public boolean isFull() {
            return head == (tail + 1) % capacity;
        }

    }
}

输出结果：

头指针: 0	尾指针: 0	队列大小: 0	容量: 6
出队： --> null
入队：1 --> true
入队：2 --> true
入队：3 --> true
入队：4 --> true
入队：5 --> true
头指针: 0	尾指针: 5	队列大小: 5	容量: 6
出队： --> 1
入队：6 --> true
头指针: 1	尾指针: 0	队列大小: 5	容量: 6
入队：7 --> false
出队： --> 2
出队： --> 3
头指针: 3	尾指针: 0	队列大小: 3	容量: 6
入队：8 --> true
入队：9 --> true
头指针: 3	尾指针: 2	队列大小: 5	容量: 6
出队： --> 4
出队： --> 5
出队： --> 6
出队： --> 8
出队： --> 9
头指针: 2	尾指针: 2	队列大小: 0	容量: 6
入队：10 --> true
头指针: 2	尾指针: 3	队列大小: 1	容量: 6

推荐阅读

• 《 数组 》
• 《 稀疏数组 》
• 《 链表（单链表、双链表、环形链表） 》
• 《 栈 》
• 《 队列 》
• 《 树 》
• 《 二叉树 》
• 《 二叉查找树（BST） 》
• 《 AVL树（平衡二叉树） 》
• 《 B树 》
• 《 散列表（哈希表） 》