关注公众号：EZ大数据（ID：EZ_DATA）。每天进步一点点，感觉很爽！
各位大佬好，今天又是新的一周，天气渐凉，2020已进入下半程的冲刺阶段。
今天我们来研究一波队列Queue。目标有三个：认识队列、实现队列（数组队列和循环队列）以及数组队列和循环队列的区别。
首先呢，队列也是一种线性结构，相比于数组，队列对应的操作也是数组的子集。不过，区别于栈，队列是一种只能从一端（队尾）添加元素，只能从另一端（队首）取出元素。所以说，队列是一种先进先出的数据结构First In First Out（FIFO）。
OK，接下来我们直接来看队列Queue的实现。具体实现方法如下（数组队列）：
1.void enqueue 队列添加元素
2.E dequeue() 队列取出元素
3.E getFront() 获取队列队首元素
4.int getSize() 获取队列元素个数
5.boolean isEmpty() 判断队列是否为空
老样子，我们还是基于之前的动态数组代码来实现队列。好了，话不多说，走你……
public class ArrayQueue<E> implements Queue<E> {
private Array<E> array;
public ArrayQueue() {
array = new Array<>();
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public void enqueue(E e) {
array.addLast(e);
}
@Override
public E dequeue() {
return array.removeFirst();
}
@Override
public E getFront() {
return array.getFirst();
}
}
是不是很EZ，敲代码真是一种享受啊~
OK，那么我们来看看具体的时间复杂度：
1.void enqueue(E) O(1)
2.E dequeue() O(n)
3.E getFront() O(1)
4.int getSize() O(1)
5.boolean isEmpty() O(1)
为何出队操作dequeue是O(n)的时间复杂度呢，这是因为当队首元素取出后，队列的所有元素都向前移动一位。那么有没有一种可能，使得dequeue()的操作也是O(1)呢？
当然可以的啦，那么下面我们就一起来看看循环队列的骚操作。
我们用front来记录队首元素的位置，用tail来记录下一次新元素入队时的位置。然后我们大家来设想一下，当队首元素取出后，让保持其他元素不变，而只改变front的指向就可以了。
当队列整体为空时，front和tail都指向起始位置，那么此时front==tail，也就表示队列为空。即下图所示：
随后，当队列添加元素时，tail往后移，此时示意图如下：
当队列里取出元素后，我们不需要所有的元素都移动，只需要让front指向的位置发生移动即可。
那么继续往队列里添加元素，当队列最后一个位置也插入元素，那么tail就不能再向后移动位置了，但是由于我们队首的元素已出队列，所以队列前面还有位置，那么此时位置7的下一个索引，其实是0的位置，也就是说，tail的移动不是简单的tail++，而是tail+1/capacity的位置，至此这就是循环队列的由来。
此时还有一个问题，因为我们之前说过，当front==tail的时候队列为空，而当0的位置继续插入元素，那么tail到1,如果此时1再插入元素，那么tail向后移动，也就说此时front和tail又相等了。所以，(tail+1)%c==front表示队列满，我们空出一个位置，留给tail。
原理讲了这么多，我们直接来看代码：
@Override
public void enqueue(E e) {
if ((tail + 1) % data.length == front) {
resize(getCapacity() * 2);
}
data[tail] = e;
tail = (tail + 1) % data.length;
size++;
}
@Override
public E dequeue() {
if (isEmpty()) {
throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
}
E ret = data[front];
data[front] = null;
front = (front + 1) % data.length;
size--;
if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
resize(getCapacity() / 2);
}
return ret;
}
@Override
public E getFront() {
if (isEmpty()) {
throw new IllegalArgumentException("Queue is empty.");
}
return data[front];
}
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity + 1];
for (int i = 0; i < size; i++) {
newData[i] = data[(i + front) % data.length];
}
data = newData;
front = 0;
tail = size;
}
}
限于篇幅呢，我就只把最关键的代码贴上来。主要也就是描述队列添加元素，删除元素中tail位置的变化，具体的逻辑请参考上面的概述。
对于数组队列和循环队列而言，差别就在于出队操作时的时间复杂度。循环队列的出队操作是O(1)。
接下来，我们来测试一波循环队列和数组队列的效率。测试代码如下：
// 测试使用q运行opCount个enqueue和dequeue操作所需的时间，单位：秒
private static double testQueue(Queue<Integer> q, int opCount){
long startTime = System.nanoTime();
Random random = new Random();
for (int i = 0; i< opCount; i++){
q.enqueue(random.nextInt(Integer.MAX_VALUE));
}
for (int i = 0; i<opCount; i++){
q.dequeue();
}
long endTime = System.nanoTime();
return (endTime - startTime) / 1000000000.0;
}
上述代码主要是随机在队列中插入数据并移除队列元素，然后计算整体运行时间。然后我们测试下插入100000个数字到队列中并取出元素，两种队列的时间消耗：
public static void main(String[] args) {
int opCount = 1000000;
ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
double time1 = testQueue(arrayQueue, opCount);
System.out.println("ArrayQueue, time: " + time1 + "s");
LoopQueue<Integer> loopQueue = new LoopQueue<>();
double time2 = testQueue(loopQueue, opCount);
System.out.println("LoopQueue, time: " + time2 + "s");
}
最后运行时间如下：
ArrayQueue, time: 3.020596699s
LoopQueue, time: 0.0091292s
我们可以明显的看到循环队列的运行时间远低于数组队列。二者的主要区别就是循环队列的出队操作时间复杂度是O(1)。
好了，今天的节目到此结束，欢迎收看。
拜了个拜~
