用队列实现栈（Java实现）（思路+图示+代码）

目录

思路： 

完整代码：

---

题目：用队列实现栈  225.用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false

注意：

• 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
• 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

提示：

• 1 <= x <= 9
• 最多调用100 次 push、pop、top 和 empty
• 每次调用 pop 和 top 都保证栈不为空

示例： 

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

思路： 

  做题之前首先要思考队列和栈的区别，队列是先进先出，栈是后进先出。要想用队列实现栈，则需要两个队列。通过元素在两个队列中来回倒实现栈的操作。规定一个是用来存放元素的队列； 一个是用来进行辅助的队列。因为在来回都元素的过程中，两个队列的功能需要不停的更换.即现在 queue1 用来存放元素，但进行完某操作后，queue1 可能就用来作为辅助了。所以再定义两个引用，方便操作。所以有 4 个引用，但队列还是 2 个。

一、 void push(int x) 将元素 x 压入栈顶： 直接将元素放入 存放元素队列 即可。

二、int pop() 移除并返回栈顶元素： 

假设现在栈中有 1、2、3、4 4个元素，并且压栈顺序从 1 开始，所以要出栈要先出 4 。
假设此时 存放元素队列为 queue1 ，辅助队列为 queue2 。

第一次 pop ：

1. 将 存放元素队列 中的 1、2、3 放入 辅助队列；将 存放元素队列 和 辅助队列 的指向进行调换，即此时 queue1 为 辅助队列，queue2 为 存储元素队列。此时，辅助队列中只有一个 4 ， 存储元素队列中有 1、2、3。
2. 将 辅助队列中的唯一的元素 4 出队列。

第二次 pop ：

1. 将 存放元素队列中的 1、2 放入 辅助队列；将 存放元素队列 和 辅助队列 的指向进行调换，即此时 queue1 为 存放元素队列，queue2 为 辅助队列。此时，辅助队列中只有一个 3，存储元素队列中有 1、 2。
2. 将 辅助队列中的唯一的元素 3 出队列。

总结：

• 取出栈顶元素操作，假设先前的 存放元素队列 中的元素数量为 size 个。
• 则需要将前 size - 1 个元素放入 辅助队列中，然后将 存放元素队列 中剩下的一个元素（最后压入的一个元素）弹出栈（出队列）。
• 因为进行完这个操作后，之前传入的元素都到了 辅助队列，而我们之后的操作还要从 存放元素队列 移动元素。
• 所以要将这两个队列的引用进行交换，让 存放元素队列 始终指向的队列始终有我们之前传入的元素。

图解：

三、int top() 返回栈顶元素：

   查看栈顶元素操作，和 pop 操作类似，只是不删除元素，将 辅助队列 中的元素弹出后，再在 存放元素队列 中 传入这个元素，最后再进行引用的交换。
  注意：这里不能使用 peek 是因为后面的操作要将引用交换，如果 辅助队列 中还有元素，交换后再操作会造成查看的数据不正确的错误。

图解： 

 

四、 boolean empty() 如果栈是空的，返回 true ；否则，返回 false：直接根据 存放元素队列 判断即可。

完整代码：

public class MyStack {
    private final Queue<Integer> queue1 = new LinkedList<>();
    private final Queue<Integer> queue2 = new LinkedList<>();
    private Queue<Integer> 存放元素队列 = queue1;
    private Queue<Integer> 辅助队列 = queue2;
    public MyStack() {
    //构造方法
    }

    //将元素 x 压入栈顶
    public void push(int x) {
        存放元素队列.offer(x);
    }

    //移除并返回栈顶元素
    public int pop() {
        //因为题目说明了每次调用 pop 和 top 都保证栈不为空，所以不用考虑栈为空的情况
        int size = 存放元素队列.size();
        for (int i = 0; i < size - 1; i++) {
            int e = 存放元素队列.poll();
            辅助队列.offer(e);
        }
        int ans = 存放元素队列.poll();
        Queue<Integer> t = 存放元素队列;
        存放元素队列 = 辅助队列;
        辅助队列 = t;
        return ans;
    }

    //返回栈顶元素
    public int top() {
        int size = 存放元素队列.size();
        for (int i = 0; i < size - 1; i++) {
            int e = 存放元素队列.poll();
            辅助队列.offer(e);
        }
        int ans = 存放元素队列.poll();
        辅助队列.offer(ans);

        Queue<Integer> t = 存放元素队列;
        存放元素队列 = 辅助队列;
        辅助队列 = t;
        return ans;
    }

    //如果栈是空的，返回 true ；否则，返回 false
    public boolean empty() {
        if (存放元素队列.isEmpty() && 辅助队列.isEmpty()) {
            return true;
        }
        return false;
    }
}