数据结构之队列

队列

队列是只允许在一端进行插入，在另一端进行删除的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO，允许插入的一端叫队尾，允许删除的一端叫队头。

线性表有顺序存储和链式存储，栈是线性表，所以有这两种存储方式，同样，队列作为特殊的线性表，也有两种存储方式。

队列的顺序存储结构：

假设我们有一个n个元素队列，则顺序存储的队列需要一个大于n的数组，并且把队列的元素存储到数组的前n个单元里，数组下标为0的是队头，入队操作就是在队尾添加一个元素，因为不需要移动任何元素，时间复杂度为O(1)，如下图：

 队列元素的出列是在队头，也就是下标为0的地方，那么意味着队列中的所有元素都要往前移动，保证队头不为空，时间复杂度为O(n)，如下图：

 上面说到了出列需要把所有元素都往前移，那么我们如果不移动可不可以呢？

如果我们去掉了队列的元素必须存储在数组前n个单元这一条件，也就是队头不一定需要在下标为0的地方，那么出队的性能就大大增加了，如下图：

为了避免只有一个元素时，队头和队尾重合使处理变得麻烦，所以引入两个指针，front指向队头，rear指向队尾元素的下一个位置，这样front和rear相等时，这个时候就是空队列。假设长度为5的数组，初始状态空队列，front和rear指针均指向下标为0的位置，然后入队a1,a2,a3,a4, front指针依然指向 下标为0的地方，而rear指针指向下标为4的位置。如下图：

 出队a1,a2,则front指针指向下标为2的地方，rear位置不变，此时再入队a5，此时front指针不变，rear移到数组之外，如下图：

 这样就会出现一个假溢出的状况，因为数组末尾元素已经被占用，再往后加，就会出现数组下标越界的问题，但是我们0和1的地方其实还空着，解决这种问题的方法就是后面满了，在从头开始，也就是头尾相接的循环，我们把这种队列称为循环队列。

接着上面的例子，我们将rear指针指向下标为0的地方

 接着入队a6,将它放置于下标为0处，rear指向下标为1的地方

 接着入队a7，则rear和front重合，同时指向下标为2的地方

 

刚刚我们提到了空队列时front等于rear，现在当队列满了的时候front也等于rear,那我们怎么区分呢？

我们有两种方法：

1. 办法一设置一个标志变量flag,当front==rear，且flag=0时队列为空，当front==rear,且flag=1时队列满
2. 办法二当队列为空时，front==rear,当队列满时，我们保留一个元素空间，也就是队列满时，数组中还有一个空闲单元,如下图所示，

 我们重点讨论第二种方法，由于rear可能比front大，也有可能比front小，所以他们只相差一个情况下就是满的情况，但也可能差整整一圈，所以若队列的最大长度为QueueSize,那么队列满的条件是（rear+1）%QueueSize == front,比如上图所示，QueueSize=5.当上图左边中front=0.rear=4,(4+1)%5=0,所以此时队列已满。如上图右边所示，front=2,rear=1,(1+1)%5=2,所以此时队列也是满的。通用的计算队列长度公式为：（rear-front+QueueSize）%QueueSize

循环队列顺序存储结构实现代码：

class MyCircularQueue {

    private int[] data;
    private int front;
    private int rear;
    private int MaxLen;

    /** Initialize your data structure here. Set the size of the queue to be k. */
    public MyCircularQueue(int k) {
        data = new int[k];
        front = -1;
        rear = -1;
        MaxLen = k;
    }

    /** Insert an element into the circular queue. Return true if the operation is successful. */
    public boolean enQueue(int value) {
        if (isFull()){
            return false;
        }
        if (isEmpty()){
            front = 0;
        }
        rear = (rear+1)%MaxLen;
        data[rear] = value;
        return true;
    }

    /** Delete an element from the circular queue. Return true if the operation is successful. */
    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }
        if (front == rear) {
            front = -1;
            rear = -1;
            return true;
        }
        front = (front + 1) % MaxLen ;
        return true;
    }

    /** Get the front item from the queue. */
    public int Front() {
        if(isEmpty()){
            return -1;
        }
        return data[front];
    }

    /** Get the last item from the queue. */
    public int Rear() {
        if(isEmpty()){
            return -1; 
        }
        return data[rear];
    }

    /** Checks whether the circular queue is empty or not. */
    public boolean isEmpty() {
        return front == -1 ;
    }

    /** Checks whether the circular queue is full or not. */
    public boolean isFull() {
        return  (rear + 1) % MaxLen == front;
    }

}

队列的链式存储结构：

队列的链式存储结构其实就是线性表的单链表，只不过它能尾进头出，简称为链队列。我们将队头指针指向链队列的头结点，而队尾指向终端节点。

空队列时，front和rear都指向头结点

 链队列代码实现

package linkqueue;
 
public class LinkQueue {
     
    class Element
    {
        Object elem;
        Element next;
    }
     
    private Element front;
    private Element rear;
    private Element header = null;
     
    /**
     * 初始化队列
     * */
    void initQueue()
    {
        header = new Element();
        front = new Element();
        rear = new Element();
        front=header;
        rear=header;
    }
     
    /**
     * 向队列插入元素
     * */
    void enQueue(Object o)
    {
        Element e=new Element();
        e.elem=o;
        if(rear==header)//第一次插入元素
        {
            rear=e;
            header.next=e;
            front.next=e;
        }else
        {
            rear.next=e;
            rear=e;
        }
    }
     
    /**
     * 出队
     * */
    Object deQueue()
    {
        Object o = null;
        if(rear==header)
        {
            System.out.println("队列为空！");
        }else
        {
            o=front.next.elem;
            if(front.next==rear)//队中只有一个元素
            {
                front.next=header;
                rear=header;
            }else//队中大于一个元素
            {
                front.next=front.next.next;
            }
        }
        return o;
    }
     
    /**
     * 打印队列
     * */
    void print()
    {
        System.out.print("打印队列：");
        Element temp = front;
        while(temp!=rear)
        {
            System.out.print(temp.next.elem+"\t");
            temp=temp.next;
        }
        System.out.println();
    }
}

循环队列和链队列的区别：

对于循环队列和链队列的比较，从时间上来讲，他们的基本的操作都是常数时间，都是O(1)，不过循环队列是事先申请好空间，试用期间不释放，而对于链队列，每次申请和释放结点也会消耗一定的时间。对于空间上来说，循环链表必须有固定长度，所以就有了存储空间浪费的问题，而链队列不存在这个问题，尽管它需要一个指针域，但这是可以接受的，所以空间上链队列更灵活。总的来说，在确定队列最大长度的情况下，建议循环队列，无法预估长度时使用链队列。