关于算法:面试官让我手写队列差点点没写出来

栈和队列是一对好兄弟，后面咱们介绍过一篇栈的文章 (栈，不就后进先出)，栈的机制绝对简略，后入先出，就像进入一个狭小的山洞，山洞只有一个出入口，只能 后进先出 (在里面的先进来，堵在外面先进去的就有点晦气)。而队列就好比是一个隧道，前面的人跟着后面走， 后面人先进来(先入先出)。日常的排队就是队列运行模式的一个形容！

栈是一种喜新厌旧的数据结构，来了新的就会解决新的把老的先停滞在这 (咱们找人、约人办事最厌恶这种人)，队列就是假公济私的一种数据结构，排队先来先得，考究程序性，所以这种数据结构在程序设计、中间件等都十分宽泛的利用，例如音讯队列、FIFO 磁盘调度、二叉树层序遍历、BFS 宽度优先搜寻等等。

队列的核心理念就是：先进先出！

队列的概念：队列是一种非凡的线性表，非凡之处在于它只容许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

同时，浏览本篇文章最好先弄懂程序表的基本操作和栈的数据结构！学习效果更佳！

咱们设计队列时候能够抉择一个规范，这里就拿力扣 622 设计循环队列作为队列设计的规范。

队头 front：删除数据的一端。

队尾 rear： 插入数据的一端。

对于数组 ，从数组前面插入更容易，数组后面插入较艰难，所以个别用数组实现的队列队头在数组后面，队尾在数组前面；而对于链表，插入删除在中间别离进行那么头部(后面) 删除尾部插入最不便的抉择。

实现办法：

MyCircularQueue(k): 结构器，设置队列长度为 k。
Front: 从队首获取元素。如果队列为空，返回 -1。
Rear: 获取队尾元素。如果队列为空，返回 -1。
enQueue(value): 向循环队列插入一个元素。如果胜利插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果胜利删除则返回真。
isEmpty(): 查看循环队列是否为空。
isFull(): 查看循环队列是否已满。

依照上述的介绍，咱们很容易晓得数组实现的形式。用数组模仿示意队列。要思考初始化，插入，问题。

在这个一般队列一些操作须要留神的有：

初始化：数组的 front 和 rear 都指向 0. (front 和 rear 下标相等的时候阐明队列为空)

入队：队不满，数组不越界，先队尾地位传值，再队尾下标 +1(队尾 rear 实际上超前一位，为了辨别空队列状况)

出队：队不空，先取队头地位元素，在队头 +1。

然而很容易发现问题，每个空间域只能利用一次，造成空间极度节约，非常容易越界！

针对上述的问题。有个较好的解决办法！就是对 曾经申请 的(数组)内存反复利用。这就是咱们所说的循环队列。循环队列的一个益处是咱们能够利用这个队列之前用过的空间。在一个一般队列里，一旦一个队列满了，咱们就不能插入下一个元素，即便在队列后面仍有空间。然而应用循环队列，咱们能应用这些空间去存储新的值。

数组实现的循环队列就是在 逻辑上 作批改。因为咱们队列中只须要 front 和 rear 两个指针。rear 在逻辑上在前面，front 在逻辑上是在后面的，但实际上它们不肯定谁在前谁在后，在计算间隔的时候须要给 rear 先补上数组长度减去 front，而后求余即可。

初始化：数组的 front 和 rear 都指向 0. 这里须要留神的是：front 和 rear 位于同一个地位时候，证实队列外面是空的。还有在这里我具体实现时候将数组申请大了一个地位空进去，避免队列满的状况又造成 front 和 rear 在同一个地位。

入队：队不满，先队尾地位传值，再rear=(rear + 1) % maxsize;

出队：队不空，先取队头地位元素，front=(front + 1)% maxsize;

这里出队入队指标相加如果遇到最初须要转到头地位，这里间接 + 1 求余找到地位 (相比判断是否在最初更加简洁)，其中maxsize 是数组理论大小。

是否为空：return rear == front;

大小：return (rear+maxsize-front)%maxsize; 这里很容易了解，一张图就能解释分明，无论是 front 理论在前在后都能满足要求。

这外面有几个大家须要留神的，就是指标相加如果遇到最初须要转到头的话。能够判断是否到数组开端地位。也能够间接 + 1 求余。其中 maxsize 是数组理论大小。

具体实现：

public class MyCircularQueue {private int data[];// 数组容器
    private int front;// 头
    private int rear;// 尾
    private int maxsize;// 最大长度
    public MyCircularQueue(int k) {data = new int[k+1];
        front = 0;
        rear = 0;
        maxsize = k+1;
    }

    public boolean enQueue(int value)  {if (isFull())
            return  false;
        else {data[rear] = value;
            rear=(rear + 1) % maxsize;
        }
        return  true;
    }

    public boolean deQueue() {if (isEmpty())
            return false;
        else {front=(front+1)%maxsize;
        }
        return  true;
    }

    public int Front() {if(isEmpty())
            return -1;
        return data[front];
    }

    public int Rear() {if(isEmpty())
            return -1;
        return data[(rear-1+maxsize)%maxsize];
    }

    public boolean isEmpty() {return rear == front;}

    public boolean isFull() {return (rear + 1) % maxsize == front;
    }
}

对于链表实现的队列，要依据先进先出的规定思考头和尾的地位

咱们晓得队列是先进先出的，对于链表，咱们能采纳单链表尽量采纳单链表，能不便尽量不便，同时还要兼顾效率。应用链表大略有两个实现计划：

计划一 如果队列头设在链表尾，队列尾设在链表头。那么 队尾进队插入 在链表头部插入没问题，容易实现，然而如果 队头删除 在链表尾部进行，如果不设置尾指针要遍历到队尾，然而设置尾指针删除须要将它前驱节点 须要双向链表，都挺麻烦的。

计划二 如果队列头设在链表头，队列尾设在链表尾，那么 队尾进队插入 在链表尾部插入没问题 (用尾指针能够间接指向 next)，容易实现，如果 队头删除 在链表头部进行也很容易，就是咱们后面常说的 头节点删除节点。

所以咱们最终采取的是计划 2 的带头节点、带尾指针的单链表!

次要操作为：

初始化：设立一个头结点，是 front 和 rear 都先指向它。

入队：rear.next=va;rear=va;（va 为被插入节点）

出队：队不空，front.next=front.next.next; 经典带头节点删除，然而如果仅有一个节点删除时候，须要多加一个 rear=front，不然 rear 就失联啦。

是否为空：return rear == front; 或者自定义保护 len 判断return len==0

大小：节点 front 遍历到 rear 的个数，或者自定义保护 len 间接返回(这里并没实现)。

实现代码：

public class MyCircularQueue{
     class node {
        int data;// 节点的后果
        node next;// 下一个连贯的节点
        public node() {}
        public node(int data) {this.data = data;}
    }
    node front;// 相当于 head 带头节点的
    node rear;// 相当于 tail/end
    int maxsize;// 最大长度
    int len=0;
    public MyCircularQueue(int k) {front=new node(0);
        rear=front;
        maxsize=k;
        len=0;
    }
    public boolean enQueue(int value)  {if (isFull())
            return  false;
        else {node va=new node(value);
            rear.next=va;
            rear=va;
            len++;
        }
        return  true;
    }
    public boolean deQueue() {if (isEmpty())
            return false;
        else {
            front.next=front.next.next;
            len--;
            // 留神 如果被删完 须要将 rear 指向 front
            if(len==0)
                rear=front;
        }
        return  true;
    }

    public int Front() {if(isEmpty())
            return -1;
        return front.next.data;
    }

    public int Rear() {if(isEmpty())
            return -1;
        return rear.data;
    }

    public boolean isEmpty() {
        return  len==0;
        //return rear == front;
    }

    public boolean isFull() {return len==maxsize;}    
}

设计实现双端队列，其实你常常应用的 ArrayDeque 就是一个经典的双向队列，其基于数组实现，效率十分高。咱们这里实现的双向队列模板基于力扣 641 设计循环双端队列。
你的实现须要反对以下操作：

MyCircularDeque(k)：构造函数, 双端队列的大小为 k。
insertFront()：将一个元素增加到双端队列头部。如果操作胜利返回 true。
insertLast()：将一个元素增加到双端队列尾部。如果操作胜利返回 true。
deleteFront()：从双端队列头部删除一个元素。如果操作胜利返回 true。
deleteLast()：从双端队列尾部删除一个元素。如果操作胜利返回 true。
getFront()：从双端队列头部取得一个元素。如果双端队列为空，返回 -1。
getRear()：取得双端队列的最初一个元素。如果双端队列为空，返回 -1。
isEmpty()：查看双端队列是否为空。
isFull()：查看双端队列是否满了。

其实有了下面的根底，实现一个双端队列非常容易，有很多操作和单端的循环队列是统一的，只有多了一个 队头插入 和队尾删除 的操作，两个操作别离简略的剖析一下：

队头插入：队友 front 下标地位自身是有值的，所以要将 front 退后一位而后再赋值，不过要思考是否为满或者数组越界状况。

队尾删除：只须要 rear 地位减 1，同时也要思考是否为空和越界状况。

具体实现代码：

public class MyCircularDeque {private int data[];// 数组容器
    private int front;// 头
    private int rear;// 尾
    private int maxsize;// 最大长度
    /* 初始化 最大大小为 k */
    public MyCircularDeque(int k) {data = new int[k+1];
        front = 0;
        rear = 0;
        maxsize = k+1;
    }

    /** 头部插入 */
    public boolean insertFront(int value) {if(isFull())
            return false;
        else {front=(front+maxsize-1)%maxsize;
            data[front]=value;
        }
        return  true;
    }

    /** 尾部插入 */
    public boolean insertLast(int value) {if(isFull())
            return  false;
        else{data[rear]=value;
            rear=(rear+1)%maxsize;
        }
        return  true;
    }

    /** 失常头部删除 */
    public boolean deleteFront() {if (isEmpty())
            return false;
        else {front=(front+1)%maxsize;
        }
        return  true;
    }

    /** 尾部删除 */
    public boolean deleteLast() {if(isEmpty())
            return false;
        else {rear=(rear+maxsize-1)%maxsize;
        }
        return true;
    }

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

    /** Get the last item from the deque. */
    public int getRear() {if(isEmpty())
            return -1;
        return  data[(rear-1+maxsize)%maxsize];
    }

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

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

对于队列来说数据结构相比栈简单一些，然而也不是很难，搞懂先进先出而后用数组或者链表实现即可。

对于数组，队尾 tail 指向的地位是空的，而链表的 front（head 一样）为头指针为空的，所以在不同构造实现雷同成果的办法须要留神一下。

数组实现的循环队列可能很大水平利用数组空间，而双向队列则是既能当队列又能当栈的一种高效数据结构，把握还是很有必要的。

最初，笔者程度无限，如果有纰漏和不足之处 还请指出 。另外，如果感觉不错能够点个赞，关注 集体公众号 ：bigsai 更多常常与你分享，关注回复bigsai 获取精心筹备的学习材料一份！

关于算法:面试官让我手写队列差点点没写出来

前言

队列介绍

一般队列

循环队列(数组实现)

循环队列(链表实现)

双向队列(加餐)

总结

Just My Socks（注册教程内含优惠码）

关于算法:面试官让我手写队列差点点没写出来

前言

队列介绍

一般队列

循环队列(数组实现)

循环队列(链表实现)

双向队列(加餐)

总结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）