算法与数据结构基础<三>----数据结构基础之栈和队列加强之实现双端队列

在上一次https://www.cnblogs.com/webor2006/p/14216904.html咱们学习了栈和队列这俩基本数据结构了，接下来则会进一步深入加强，以加深对于它们的了解，也是面试时很有可能会被提到的~~

实现双端队列：

理论：

接下来准备实现一个全新的数据结构---双端队列，其实跟我们之前所学的队列关系紧密，我们知道，对于普通队列来说“只能从一端（队尾）添加元素，只能从另一端（队首）取出元素”，也就是先进先出对吧，但是！！！对于双端队列就不一样了，它的特点是：

• 可以在队列的两端添加元素
• 可以在队列的两端删除元素

 而在方法设计上，通常就会对应有这四个方法：

• addFront，addLast
• removeFront，removeLast

而通常对于双端队列的命名是Deque，百度一下：

 

思考：

在正式实现它之前，先来挼一下实现思路，由于它其实也是建立在咱们之前实现的队列基础之上的，而对于双端队列主要就是涉及到如下四个方法：

• addFront，addLast
• removeFront，removeLast

而对于普通队列来说，“添加是从队尾开始的，而移除是从队首的”，可能有些人看到这句话有点歧义，对照着图来理解就对了：

 

队首是在下面，而队尾是在上面，不要理解反了，关于这块还有问题的可以参考它https://www.cnblogs.com/webor2006/p/14216904.html，那么回到我们这边要实现的双端队列的四个方法，很明显有两个完全跟我们之前实现的队列的是一模一样的逻辑，那就是：

• addLast，其实就是咱们之前普通队列的enqueue
• removeFront，其实就是咱们之前普通队列的dequeue

那么，咱们的关键就是只需要实现如下两个方法了：

• addFront
• removeLast

而要实现这两个方法，关键在于正确地计算出经过队列元素的添加和删除之后的front和tail，所以经过这么一分析双端队列貌似也没那么难，在正式实现之前，先把之前实现的队列的代码贴出来供回忆参考：

// 在这一版LoopQueue的实现中，我们将不浪费那1个空间
public class LoopQueue2<E> implements Queue<E> {

    private E[] data;
    private int front, tail;
    private int size;

    public LoopQueue2(int capacity) {
        data = (E[]) new Object[capacity]; // 由于不浪费空间，所以data静态数组的大小是capacity,而不是capacity + 1
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue2() {
        this(10);
    }

    public int getCapacity() {
        return data.length;
    }

    @Override
    public boolean isEmpty() {
        // 注意，我们不再使用front和tail之间的关系来判断队列是否为空，而直接使用size
        return size == 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public void enqueue(E e) {

        // 注意，我们不再使用front和tail之间的关系来判断队列是否为满，而直接使用size
        if (size == getCapacity())
            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];
        for (int i = 0; i < size; i++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public String toString() {

        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d , capacity = %d
", size, getCapacity()));
        res.append("front [");

        // 注意，我们的循环遍历打印队列的逻辑也有相应的更改
        for (int i = 0; i < size; i++) {
            res.append(data[(front + i) % data.length]);
            if ((i + front + 1) % data.length != tail)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {

        LoopQueue<Integer> queue = new LoopQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);

            if (i % 3 == 2) {
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

实践： 

1、新建文件，拷贝原来队列复用的代码：

既然跟我们之前实现的队列逻辑基本差不多，所以可以把用得到的代码拷贝过来，这里就不重复解释了：

/**
 * 双端队列
 */
public class Deque<E> {

    private E[] data;
    private int front, tail;
    private int size; // 方便起见，我们的 Deque 实现，将使用 size 记录 deque 中存储的元素数量

    public Deque(int capacity){
        data = (E[])new Object[capacity]; // 由于使用 size，我们的 Deque 实现不浪费空间
        front = 0;
        tail = 0;
        size = 0;
    }

    public Deque(){
        this(10);
    }

    public int getCapacity(){
        return data.length;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    public int getSize(){
        return size;
    }

    // addLast 的逻辑和我们之前实现的队列中的 enqueue 的逻辑是一样的
    public void addLast(E e){

        if(size == getCapacity())
            resize(getCapacity() * 2);

        data[tail] = e;
        tail = (tail + 1) % data.length;
        size ++;
    }

    // addFront 是新的方法，请大家注意
    public void addFront(E e){
        //TODO
    }

    // removeFront 的逻辑和我们之前实现的队列中的 dequeue 的逻辑是一样的
    public E removeFront(){

        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(getSize() == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    // removeLast 是新的方法，请大家注意
    public E removeLast(){
        //TODO
        return null;
    }

    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return data[front];
    }

    // 因为是双端队列，我们也有一个 getLast 的方法，来获取队尾元素的值
    public E getLast(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        //TODO，这块需要调整逻辑
        return null;
    }

    private void resize(int newCapacity){
        E[] newData = (E[])new Object[newCapacity];
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public String toString(){

        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d , capacity = %d
", getSize(), getCapacity()));
        res.append("front [");
        for(int i = 0 ; i < size ; i ++){
            res.append(data[(i + front) % data.length]);
            if(i != size - 1)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }
}

2、addFont()方法实现：

它的实现代码也不难，如下：

    // addFront 是新的方法，请大家注意
    public void addFront(E e){
        if(size == getCapacity())
            resize(getCapacity() * 2);

        // 我们首先需要确定添加新元素的索引位置
        // 这个位置是 front - 1 的地方
        // 但是要注意，如果 front == 0，新的位置是 data.length - 1 的位置
        front = front == 0 ? data.length - 1 : front - 1;
        data[front] = e;
        size ++;
    }

其中当front==0的时候，其要添加的位置是data.length-1呢？看图说话：

而如果front!=0的情况，当然就是插入到front-1的位置了喽。

3、removeLast()：

    // removeLast 是新的方法，请大家注意
    public E removeLast(){
        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        // 计算删除掉队尾元素以后，新的 tail 位置
        tail = tail == 0 ? data.length - 1 : tail - 1;
        E ret = data[tail];
        data[tail] = null;
        size --;
        if(getSize() == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

理解一下，当tail==0时：

此时removeLast是不是得回到第7个位置的“h”元素需要被删除了？而如果tail!=0，那当然移除的是tail-1个元素了。

4、getLast()：

队尾的元素直接根据tail指向的前一个位置来获取，如下：

5、测试： 

/**
 * 双端队列
 */
public class Deque<E> {

    private E[] data;
    private int front, tail;
    private int size; // 方便起见，我们的 Deque 实现，将使用 size 记录 deque 中存储的元素数量

    public Deque(int capacity){
        data = (E[])new Object[capacity]; // 由于使用 size，我们的 Deque 实现不浪费空间
        front = 0;
        tail = 0;
        size = 0;
    }

    public Deque(){
        this(10);
    }

    public int getCapacity(){
        return data.length;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    public int getSize(){
        return size;
    }

    // addLast 的逻辑和我们之前实现的队列中的 enqueue 的逻辑是一样的
    public void addLast(E e){

        if(size == getCapacity())
            resize(getCapacity() * 2);

        data[tail] = e;
        tail = (tail + 1) % data.length;
        size ++;
    }

    // addFront 是新的方法，请大家注意
    public void addFront(E e){
        if(size == getCapacity())
            resize(getCapacity() * 2);

        // 我们首先需要确定添加新元素的索引位置
        // 这个位置是 front - 1 的地方
        // 但是要注意，如果 front == 0，新的位置是 data.length - 1 的位置
        front = front == 0 ? data.length - 1 : front - 1;
        data[front] = e;
        size ++;
    }

    // removeFront 的逻辑和我们之前实现的队列中的 dequeue 的逻辑是一样的
    public E removeFront(){

        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(getSize() == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    // removeLast 是新的方法，请大家注意
    public E removeLast(){
        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        // 计算删除掉队尾元素以后，新的 tail 位置
        tail = tail == 0 ? data.length - 1 : tail - 1;
        E ret = data[tail];
        data[tail] = null;
        size --;
        if(getSize() == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return data[front];
    }

    // 因为是双端队列，我们也有一个 getLast 的方法，来获取队尾元素的值
    public E getLast(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        //TODO，这块需要调整逻辑
        return null;
    }

    private void resize(int newCapacity){
        E[] newData = (E[])new Object[newCapacity];
        for(int i = 0 ; i < size ; i ++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public String toString(){

        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d , capacity = %d
", getSize(), getCapacity()));
        res.append("front [");
        for(int i = 0 ; i < size ; i ++){
            res.append(data[(i + front) % data.length]);
            if(i != size - 1)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args){
        // 在下面的双端队列的测试中，偶数从队尾加入；奇数从队首加入
        Deque<Integer> dq = new Deque<>();
        for(int i = 0 ; i < 16 ; i ++){
            if(i % 2 == 0) dq.addLast(i);
            else dq.addFront(i);
            System.out.println(dq);
        }

        // 之后，我们依次从队首和队尾轮流删除元素
        System.out.println();
        for(int i = 0; !dq.isEmpty(); i ++){
            if(i % 2 == 0) dq.removeFront();
            else dq.removeLast();
            System.out.println(dq);
        }
    }
}

运行看一下：

Queue: size = 1 , capacity = 10
front [0] tail
Queue: size = 2 , capacity = 10
front [1, 0] tail
Queue: size = 3 , capacity = 10
front [1, 0, 2] tail
Queue: size = 4 , capacity = 10
front [3, 1, 0, 2] tail
Queue: size = 5 , capacity = 10
front [3, 1, 0, 2, 4] tail
Queue: size = 6 , capacity = 10
front [5, 3, 1, 0, 2, 4] tail
Queue: size = 7 , capacity = 10
front [5, 3, 1, 0, 2, 4, 6] tail
Queue: size = 8 , capacity = 10
front [7, 5, 3, 1, 0, 2, 4, 6] tail
Queue: size = 9 , capacity = 10
front [7, 5, 3, 1, 0, 2, 4, 6, 8] tail
Queue: size = 10 , capacity = 10
front [9, 7, 5, 3, 1, 0, 2, 4, 6, 8] tail
Queue: size = 11 , capacity = 20
front [9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10] tail
Queue: size = 12 , capacity = 20
front [11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10] tail
Queue: size = 13 , capacity = 20
front [11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12] tail
Queue: size = 14 , capacity = 20
front [13, 11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12] tail
Queue: size = 15 , capacity = 20
front [13, 11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12, 14] tail
Queue: size = 16 , capacity = 20
front [15, 13, 11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12, 14] tail

Queue: size = 15 , capacity = 20
front [13, 11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12, 14] tail
Queue: size = 14 , capacity = 20
front [13, 11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12] tail
Queue: size = 13 , capacity = 20
front [11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10, 12] tail
Queue: size = 12 , capacity = 20
front [11, 9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10] tail
Queue: size = 11 , capacity = 20
front [9, 7, 5, 3, 1, 0, 2, 4, 6, 8, 10] tail
Queue: size = 10 , capacity = 20
front [9, 7, 5, 3, 1, 0, 2, 4, 6, 8] tail
Queue: size = 9 , capacity = 20
front [7, 5, 3, 1, 0, 2, 4, 6, 8] tail
Queue: size = 8 , capacity = 20
front [7, 5, 3, 1, 0, 2, 4, 6] tail
Queue: size = 7 , capacity = 20
front [5, 3, 1, 0, 2, 4, 6] tail
Queue: size = 6 , capacity = 20
front [5, 3, 1, 0, 2, 4] tail
Queue: size = 5 , capacity = 10
front [3, 1, 0, 2, 4] tail
Queue: size = 4 , capacity = 10
front [3, 1, 0, 2] tail
Queue: size = 3 , capacity = 10
front [1, 0, 2] tail
Queue: size = 2 , capacity = 5
front [1, 0] tail
Queue: size = 1 , capacity = 2
front [0] tail
Queue: size = 0 , capacity = 1
front [] tail

其中可以稍加说明一下测试结果：

没有size成员变量的循环队列：

理论：

在上面实现中，咱们使用了一个size变量来记录队列元素的个数，跟之前学习队列数据结构实现的一样，也可以用另一种方式来实现，那就是不浪费这个size变量的空间，用front和tail来算出元素总数，所以接下来基于这个优化思想再用另一种方式来实现一下双端队列，同样是浪费一个空间，但是这里不会用到size了。

实践： 

  

/**
 * 双端队列：还是浪费一个空间，但是不使用size
 */
public class Deque2<E> {

    private E[] data;
    private int front, tail;

    public Deque2(int capacity){
        data = (E[])new Object[capacity+1];
        front = 0;
        tail = 0;
    }

    public Deque2(){
        this(10);
    }

    public int getCapacity(){
        return data.length - 1;
    }

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

    public int getSize(){
        //此时需要注意它的逻辑为：
        //如果tail >= front，很简单，队列中的元素个数就是tail-front;
        //如果tail < front，说明循环队列"循环"起来了，此时，队列中的元素个数为：tail-front+data.length
        //这个式子也可以理解为,data中没有元素的数目为front-tail，整体元素个数就是：data.length-(front-tail)
        //=data.length-front+tail
        return tail >= front ? tail - front : tail - front + data.length;
    }

    // addLast 的逻辑和我们之前实现的队列中的 enqueue 的逻辑是一样的
    public void addLast(E e){

        if ((tail + 1) % data.length == front)
            resize(getCapacity() * 2);

        data[tail] = e;
        tail = (tail + 1) % data.length;
    }

    // addFront 是新的方法，请大家注意
    public void addFront(E e){
        if ((tail + 1) % data.length == front)
            resize(getCapacity() * 2);

        // 我们首先需要确定添加新元素的索引位置
        // 这个位置是 front - 1 的地方
        // 但是要注意，如果 front == 0，新的位置是 data.length - 1 的位置
        front = front == 0 ? data.length - 1 : front - 1;
        data[front] = e;
    }

    // removeFront 的逻辑和我们之前实现的队列中的 dequeue 的逻辑是一样的
    public E removeFront(){

        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        if(getSize() == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    // removeLast 是新的方法，请大家注意
    public E removeLast(){
        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

        // 计算删除掉队尾元素以后，新的 tail 位置
        tail = tail == 0 ? data.length - 1 : tail - 1;
        E ret = data[tail];
        data[tail] = null;
        if(getSize() == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);
        return ret;
    }

    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return data[front];
    }

    // 因为是双端队列，我们也有一个 getLast 的方法，来获取队尾元素的值
    public E getLast(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        //TODO，这块需要调整逻辑
        return null;
    }

    private void resize(int newCapacity){
        E[] newData = (E[]) new Object[newCapacity + 1];
        int sz = getSize();
        for (int i = 0; i < sz; i++)
            newData[i] = data[(i + front) % data.length];

        data = newData;
        front = 0;
        tail = sz;
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d , capacity = %d
", getSize(), getCapacity()));
        res.append("front [");
        for (int i = front; i != tail; i = (i + 1) % data.length) {
            res.append(data[i]);
            if ((i + 1) % data.length != tail)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args){
        // 在下面的双端队列的测试中，偶数从队尾加入；奇数从队首加入
        Deque2<Integer> dq = new Deque2<>();
        for(int i = 0 ; i < 16 ; i ++){
            if(i % 2 == 0) dq.addLast(i);
            else dq.addFront(i);
            System.out.println(dq);
        }

        // 之后，我们依次从队首和队尾轮流删除元素
        System.out.println();
        for(int i = 0; !dq.isEmpty(); i ++){
            if(i % 2 == 0) dq.removeFront();
            else dq.removeLast();
            System.out.println(dq);
        }
    }
}

其运行结果跟第一版的是一样的。

用队列实现栈&用栈实现队列

在之前我们实现栈和队列，底层全是使用的动态数组对吧，那。。如果没有动态数组，而只有队列这么一个数据结构，你能用它来实现栈么？类似的如果只有栈这么一个数据结构，你能用它来实现一个队列么？而这两个经典算法题也出现在了leetcode中了，具体可以点击下面两个链接来查看：

用队列实现栈

用栈实现队列

当然，咱们的目标就是把实现的代码拷到Leetcode中来进行验证，且用多种方式来实现。

用队列实现栈：

基本实现：

1、定义一个队列的成员变量：

其中直接使用 Java 内置的 Queue。Java 中的 Queue 是一个接口，具体实例化它，需要选择一个数据结构。在这里，我们选择使用 LinkedList。LinkedList 是链表，关于链表，在下一次就会学习到。

2、push()：

对于一个栈来说，关键是栈顶在哪里。栈是一端入，同一端出；而队列是一端入，另一端出。那如果只给出一个队列，我们先假设入队的一端是栈顶，那么，对于这个push方法就非常简单了，直接将元素放入队列中就好了，如下：

3、pop()：移除栈顶的元素并返回

分析：

接下来的问题就来了，我们想要获得栈顶的元素，但是呢底层的数据存储在一个队列中，也就是需要获得队列中的队尾的那个元素移除并返回才对，那么问题来了：

我们只能取出队首的元素【因为是先进先出】，所以，要想拿到队尾的元素，我们就必须先把现在队列中的 n - 1 个元素都取出来。剩下的那一个元素，就是队尾的元素。

关于上面这一段，可能有点抽象，这边简单画一个图辅助理解：

目前是这么一个形态，Stack的底层是用Queue来实现的。好，接下来入栈几个元素：

此时，我想pop()取栈顶的元素的话，就应该是“C”的对吧，但是！！！请注意，此时C是在队列的队尾哟，而队列出是从队首拿的，就形成了矛盾了不是？如下：

对于上面的这段文字应该就容易理解说的啥了吧？这里一定得要搞清楚“栈顶、栈底、队首、队尾”它们之间的概念才能不会晕，这里用图再说明一下：

好，接下来核心的问题就回到了如何才能取到"C"这个栈顶的元素， 无它法：我们就必须先把现在队列中的 n - 1 个元素都取出来。剩下的那一个元素，就是队尾的元素。

但是！！！取出来是不能丢掉的，得将其保存起来，而由于这题限制了我们必须使用队列这个数据结构。所以，此时，我们可以使用另外一个队列 比如叫q2【临时保存的队列】，来存储从 q 【原队列】中取出的所有元素。最后，q 里只剩下一个元素，就是我们要拿出的“栈顶元素”。将这个元素删除后，q2 里的数据就是原始的数据，我们用 q2 覆盖 q 就好，所以这么一来，实现思路就已经明确下，下面就可以来实现了。

实现：

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {

        // 创建另外一个队列 q2
        Queue<Integer> q2 = new LinkedList<>();

        // 除了最后一个元素，将 q 中的所有元素放入 q2
        while (q.size() > 1)
            q2.add(q.remove());

        // q 中剩下的最后一个元素就是“栈顶”元素
        int ret = q.remove();

        // 此时 q2 是整个数据结构存储的所有其他数据，赋值给 q
        q = q2;

        // 返回“栈顶元素”
        return ret;
    }

4、top()：

一旦我们实现了 pop，实现 top 就简单了。我们可以复用我们已经实现的 pop，将栈顶元素拿出来，记录下来，作为返回值。然后因为 top 不会删除元素，我们再将这个值放进队列就好了。如下：

    /** Get the top element. */
    public int top() {
        int ret = pop();
        push(ret);
        return ret;
    }

5、empty()：

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q.isEmpty();
    }

6、将整个代码拷到Leetcode中进行验证：

import java.util.LinkedList;
import java.util.Queue;

public class MyStack {
    private Queue<Integer> q;

    public MyStack() {
        q = new LinkedList<>();
    }

    /** Push element x onto stack. */
    public void push(int x) {
        q.add(x);
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {

        // 创建另外一个队列 q2
        Queue<Integer> q2 = new LinkedList<>();

        // 除了最后一个元素，将 q 中的所有元素放入 q2
        while (q.size() > 1)
            q2.add(q.remove());

        // q 中剩下的最后一个元素就是“栈顶”元素
        int ret = q.remove();

        // 此时 q2 是整个数据结构存储的所有其他数据，赋值给 q
        q = q2;

        // 返回“栈顶元素”
        return ret;
    }

    /** Get the top element. */
    public int top() {
        int ret = pop();
        push(ret);
        return ret;
    }
}

7、复杂度分析：

• 初始化的构造函数复杂度，是 O(1) 的；
  
• 判断栈是否为空的 empty，复杂度，是 O(1) 的；
   
• 入栈的 push，复杂度是 O(1) 的；
  
• 出栈的 pop，因为需要把队列中所有元素都拿出来一趟，所以复杂度是 O(n) 的；
  
• 而 top，因为使用了 pop，复杂度也是 O(n) 的。
  

思考：我们可不可能将 top 的复杂度降至 O(1)？

答案是可能的！

其实，我们没有必要每次取出栈顶元素的时候，都把所有元素再拿出来一趟。

在整个类中，我们可以使用一个变量，假设就叫 top，来追踪记录栈顶元素：

import java.util.LinkedList;
import java.util.Queue;
// 小优化，使用一个变量记录栈顶元素
// 注意，提交给 Leetcode 的时候，需要将 MyStack2 改成是 MyStack
public class MyStack2 {
    private Queue<Integer> q;
    private int top;

    public MyStack2() {
        q = new LinkedList<>();
    }


    /** Push element x onto stack. */
    public void push(int x) {
        q.add(x);
        top = x;
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {

        // 创建另外一个队列 q2
        Queue<Integer> q2 = new LinkedList<>();

        // 除了最后一个元素，将 q 中的所有元素放入 q2
        while (q.size() > 1) {
            // 每从 q 中取出一个元素，都给 top 赋值
            // top 最后存储的就是 q 中除了队尾元素以外的最后一个元素
            // 即新的栈顶元素
            top = q.peek();
            q2.add(q.remove());
        }

        // q 中剩下的最后一个元素就是“栈顶”元素
        int ret = q.remove();

        // 此时 q2 是整个数据结构存储的所有其他数据，赋值给 q
        q = q2;

        // 返回“栈顶元素”
        return ret;
    }

    /** Get the top element. */
    public int top() {
        return top;
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q.isEmpty();
    }
}

将其拷到leetcode中验证一下正确性：

思考：上面的方式，push 是 O(1) 的，pop 是 O(n) 的。能不能写出一个实现，push 是 O(n) 的，pop 是 O(1) 的？

当然可以，就是想办法把栈顶的元素放到队首，也就是在push时需要对元素进行一个排序，也就是pop时直接从队列中取出就是栈顶的元素，如下：

 

核心的核心就是如何来改造这个push()方法了，怎么放呢？一样的思路，我们使用另外一个队列暂存所有的元素。我们可以先把 q 的所有元素放到 q2中，然后把新的元素入队给 q，之后，再把 q2 中暂存的元素放到 q 中，就好了：

public void push(int x) {

    Queue<Integer> q2 = new LinkedList<>();

    while(!q.isEmpty())
        q2.add(q.remove());

    q.add(x);

    while (!q2.isEmpty())
        q.add(q2.remove());
} 

这个容易理解么？下面简单用图说明一下：

此时先不着急直接入队，而是在执行它之前，先将队列中的所有元素都添加到一个临时队列中，如下：

也就是对应代码的这一段：

接着再将新添加的元素添加到第一个真正的队列中，此时的情况为：

此时再将备份的queue2中的所有元素再挪回到queue中，那么最终的形态就为：

那queue2呢？不浪费空间了么，不会的，因为它是方法的局部变量，方法执行完就会销毁的。

还有一种更加容易理解的实现方式：

public void push(int x) {

    Queue<Integer> q2 = new LinkedList<>();

    q2.add(x);
    while(!q.isEmpty())
        q2.add(q.remove());

    q = q2;
}

也就是直接给 q2 里添加新的 x，然后把 q 中所有元素再添加到 q2 中。最后，让 q 指向新的 q2就好了。

整个代码如下：

import java.util.LinkedList;
import java.util.Queue;

// 写出一个实现，push 是 O(n) 的，pop 是 O(1) 的？
public class MyStack3 {
    private Queue<Integer> q;
    public MyStack3() {
        q = new LinkedList<>();
    }

    /** Push element x onto stack. */
    public void push(int x) {
        //想办法让栈顶的元素放到队列的队首
        Queue<Integer> q2 = new LinkedList<>();

        q2.add(x);
        while(!q.isEmpty())
            q2.add(q.remove());

        q = q2;
    }

    public int pop() {
        return q.remove();
    }

    public int top() {
        return q.peek();
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q.isEmpty();
    }
}

此时我们的 pop，时间复杂度是 O(1) 的；push，时间复杂度是 O(n) 了。

同样放到Leetcode中进行验证看是不是同样好使：

思考：对于上面O(n)的push我们可不可能只是用一个队列，而不使用第二个队列解决这个问题？

对于上面咱们不是已经将push变为O(n)复杂度了么？其中它里面用了一个临时的队列来存放队首元素除外的那些元素：

那有没有可能，不借助这第二个临时的队列来达到同样的效果呢？有的，代码如下：

这个应该很容易理解，先文字描述一下：

比如，我们的队列中，元素是 1, 2, 3。对于栈来来说，添加元素 4 以后，我们希望得到 4, 1, 2, 3

可是因为 q 是队列，我们将 4 入队，得到的是 1, 2, 3, 4

现在，队列中有 4 个元素，我们只需要执行 3 次出队再入队。

第一次，出队 1 再入队 1，得到：2, 3, 4, 1

第二次，出队 2 再入队 2，得到：3, 4, 1, 2

第三次，出队 3 再入队 3，得到：4, 1, 2, 3

至此，就是我们想要的结果了。

可能文字有点抽象对吧，下面再用图解一下就清楚了：

直接将它添加到队尾中如下：

但是很明显我们是想把“C”要放到队首中，也就是“A”的位置对吧，此时再执行n-1次先出队再入队的操作，也就是针对这俩元素：

先将“A”出队，然后此时再将它添加入队，此时“A”元素是不是就跑到队尾了？

此时再出队一个再放队，那么结果就是：

是不是要入队的元素就已经放到了队首了？所以整个代码如下：

import java.util.LinkedList;
import java.util.Queue;

// push 的过程只使用一个 queue
// 注意，提交给 Leetcode 的时候，需要将 MyStack4 改成是 MyStack
public class MyStack4 {
    private Queue<Integer> q;
    public MyStack4() {
        q = new LinkedList<>();
    }

    /** Push element x onto stack. */
    public void push(int x) {
        //想办法让栈顶的元素放到队列的队首
        // 首先，将 x 入队
        q.add(x);

        // 执行 n - 1 次出队再入队的操作
        for(int i = 1; i < q.size(); i ++)
            q.add(q.remove());
    }

    public int pop() {
        return q.remove();
    }

    public int top() {
        return q.peek();
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q.isEmpty();
    }
}

同样将其拷到Leetcode中进行验证：

总结：

至此，关于用队列实现栈的多种实现就已经学会了，那如果反过来，让你用栈来实现队列呢？这也是非常经典的面试题之一，关于它下回继续。