LeetCode225. 用队列实现栈

题目：

请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入： [“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

后进先出：最后一个放入堆栈中的物体总是被最先拿出来

思路：

---

建立两个队列A，B， 将元素 x 压入栈顶的话直接将元素插入A中；
移除并返回栈顶元素，则是将A中的元素转移到B中，只剩下最后的栈顶元素时返回并删除，然后交换A B的身份，保证下次入栈的时候，还是往A中插入；
返回栈顶元素，和移除并返回栈顶元素类似，只是将A中的栈顶元素也放到B中并返回该值，并不删除该值；
判断是否为空，如果A、B两个队列都是空的，那么栈为空

---

完整代码：

class MyStack {
    private Queue<Integer> A = new LinkedList<>();
    private Queue<Integer> B = new LinkedList<>();

    public MyStack() {

    }
    public void push(int x) {
            //入栈的时候直接往A中插入
            A.offer(x);
    }

    public int pop() {
        //出栈的时候，把A中的元素弄到B中，当A中只剩一个元素时，最后那个就是被剩的元素
        if(A.isEmpty() && B.isEmpty()){//题目有要求，保证栈不为空，也可以省略
            //针对空帧的判定，人家给的不是Integer，只能随便返回
            return 0;
        }
        while (A.size() > 1){
            //将A中的元素转移到B中
            int tmp = A.poll();//出队列
            B.offer(tmp);
        }
        //A中只剩一个元素，把这个元素，作为出栈的结果
        int ret = A.poll();
        //交换A B的身份，保证下次入栈的时候，还是往A中插入
        swapAB();
        return ret;
    }

    private void swapAB() {
        Queue<Integer> tmp = A;
        A = B;
        B = tmp;
    }

    public int top() {
        //取栈顶元素和出栈类似，唯一的区别时，出栈操作是吧A的最后一个元素给删了
        //而取栈顶元素是把A的最后一个元素还要再塞回B中
        if(A.isEmpty() && B.isEmpty()){
            return -1;
        }
        int tmp = 0;
        while(A.size() > 0){
            tmp = A.poll();
            B.offer(tmp);
        }
        swapAB();
        return tmp;
    }

    public boolean empty() {
        return A.isEmpty() && B.isEmpty();
    }
}

代码分解：

• 建立两个队列

    private Queue<Integer> A = new LinkedList<>();
    private Queue<Integer> B = new LinkedList<>();

• 将元素 x 压入栈顶

//将A、B的指向交换，以便使下次插入的还是A中
private void swapAB() {
      Queue<Integer> tmp = A;
      A = B;
      B = tmp;
  }


public int pop() {
      //出栈的时候，把A中的元素弄到B中，当A中只剩一个元素时，最后那个就是被剩的元素
      if(A.isEmpty() && B.isEmpty()){//题目有要求，保证栈不为空，也可以省略
          //针对空帧的判定，人家给的不是Integer，只能随便返回
          return -1;
      }
      while (A.size() > 1){
          //将A中的元素转移到B中
          int tmp = A.poll();//出队列
          B.offer(tmp);
      }
      //A中只剩一个元素，把这个元素，作为出栈的结果
      int ret = A.poll();
      //交换A B的身份，保证下次入栈的时候，还是往A中插入
      swapAB();
      return ret;
  }

• 返回栈顶元素。

private void swapAB() {
       Queue<Integer> tmp = A;
       A = B;
       B = tmp;
   }


 public int top() {
       //取栈顶元素和出栈类似，唯一的区别时，出栈操作是吧A的最后一个元素给删了
       //而取栈顶元素是把A的最后一个元素还要再塞回B中
       if(A.isEmpty() && B.isEmpty()){
           return -1;
       }
       int tmp = 0;
       while(A.size() > 0){
           tmp = A.poll();
           B.offer(tmp);
       }
       swapAB();
       return tmp;
   }

还有另一种写法：

public int top() {
        //出栈的时候，把A中的元素弄到B中，当A中只剩一个元素时，最后那个就是被剩的元素
        if(A.isEmpty() && B.isEmpty()){//题目有要求，保证栈不为空，也可以省略
            //针对空帧的判定，人家给的不是Integer，只能随便返回
            return -1;
        }
        while (A.size() > 1){
            //将A中的元素转移到B中
            int tmp = A.poll();//出队列
            B.offer(tmp);
        }
        //A中只剩一个元素，把这个元素，作为出栈的结果
        int ret = A.poll();

        B.offer(ret);//除了这步，其他的都和pop()方法一样，这步是将栈顶元素插入到B中

        //交换A B的身份，保证下次入栈的时候，还是往A中插入
        swapAB();
        return ret;
    }

可以看到，除了 B.offer(ret)这一步外，其他的都和pop()方法一样，这两种写法在原理上是类似的。

• 判断

public boolean empty() {
       return A.isEmpty() && B.isEmpty();
   }

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/implement-stack-using-queues
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。