使用队列实现栈，双队列解法

LeetCode #225 用队列实现栈

 

分析 ：

1. 对于队列 A 来说，假如依次进来5个元素（由先至后的顺序）：1、2、3、4、5

后面这5个元素，出队列的时候，依照队列的特点 —— “先进先出”，必然是 1最先出去，5最后出队列

2. 对于栈C来说，也同样是进入5个元素，按由先至后的顺序：1、2、3、4、5

后面这5个元素，出栈的时候，依照栈的特点 —— “先进后出”，必然是 5最先出去，1最后出栈

 

那么如何用队列去实现栈的特点呢 ?

（对于图示的例子）也就是说，要满足，让5最先出去，然后，1最后出去

我们可以想到，利用两个队列去实现栈的特点 ——

1. 首先，将队列A中除了5之外的元素（1、2、3、4）全部放至队列B中，

这样队列A中就只剩下5一个元素，那么此时将5“出队”

2. 然后，等上一步完成，就是说等5成功出队后，再讲队列B中的元素4再次放至队列A中

重复步骤1 的特点即可满足要求。如图所示 ——

 

代码实现如下 ———

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


/*
使用队列实现栈的下列操作：

push(x) -- 元素 x 入栈
pop() -- 移除栈顶元素
top() -- 获取栈顶元素
empty() -- 返回栈是否为空

注意:

1. 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
2. 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
3. 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。
*/

// 双队列解法
class MyStack {
    private Queue<Integer> queueA = new LinkedList<>();
    private Queue<Integer> queueB = new LinkedList<>();

    /** Initialize your data structure here. */
    public MyStack() {

    }

    /** Push element x onto stack. */
    public void push(int x) {
        // 保证所有元素都在一个队列中
        if (queueA.isEmpty()) {
            queueB.add(x);
        }else {
            queueA.add(x);
        }
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        if (queueA.isEmpty()) {
            int len = queueB.size();
            for (int i = 0; i < len - 1; i++) {
                // 所有元素依次放入队列 A中
                queueA.add(queueB.poll());
            }
            // 队列 B的最后一个元素一定是最后进入的
            // 刚好是栈的栈顶元素
            int result = queueB.poll();
            return result;
        }
        else {
            int len = queueA.size();
            for (int i = 0; i < len - 1; i++) {
                // 所有元素依次放入队列 B中
                queueB.add(queueA.poll());
            }
            // 队列 A的最后一个元素一定是最后进入的
            // 刚好是栈的栈顶元素
            int result = queueA.poll();
            return result;
        }
    }

    /** Get the top element. */
    public int top() {
        if (queueA.isEmpty()) {
            int len = queueB.size();
            for (int i = 0; i < len - 1; i++) {
                // 所有元素依次放入队列 A中
                queueA.add(queueB.poll());
            }
            // 队列 B的最后一个元素一定是最后进入的
            // 刚好是栈的栈顶元素
            int result = queueB.poll();
            queueA.add(result);
            return result;
        }
        else {
            int len = queueA.size();
            for (int i = 0; i < len - 1; i++) {
                // 所有元素依次放入队列 B中
                queueB.add(queueA.poll());
            }
            // 队列 A的最后一个元素一定是最后进入的
            // 刚好是栈的栈顶元素
            int result = queueA.poll();
            queueB.add(result);
            return result;
        }
    }

    /** Returns whether the stack is empty. */
    // 两个队列同时为空
    public boolean empty() {
        return queueA.isEmpty() && queueB.isEmpty();
    }
}