栈和队列 - 用队列实现栈

1.题目

LeetCode: 225. 用队列实现栈

【easy】

请你仅使用两个队列实现一个后入先出（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

提示：

1 <= x <= 9

最多调用100 次 push、pop、top 和 empty

每次调用 pop 和 top 都保证栈不为空

进阶：
你能否实现每种操作的均摊时间复杂度为 O(1) 的栈？换句话说，执行 n 个操作的总时间复杂度 O(n) ，尽管其中某个操作可能需要比其他操作更长的时间。你可以使用两个以上的队列。

2.解题

方法一：用两个队列实现栈

定义两个队列，q1和q2，

当压栈的时，直接将元素压入q1即可；

当出栈时，将q1除了最后一个元素的所有元素压入q2，用临时变量x记录最后一个元素并弹出，为了保证下一次出栈的正确性，将q2所有元素再放入q1中，最后返回x；

当获取栈顶元素时，将q1除了最后一个元素的所有元素压入q2，用临时变量x记录最后一个元素，为了保证下一次获取栈顶元素的正确性，然后将最后一个元素也压入q2，再将q2所有元素放入q1，返回临时变量x即可；

当判断栈是否为空时，只需要判断q1是否为空即可。

java：

class MyStack {

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

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

    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        q1.offer(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        while (q1.size() > 1) {
            q2.offer(q1.poll());
        }
        int x = q1.poll();
        while (!q2.isEmpty()) {
            q1.offer(q2.poll());
        }
        return x;
    }
    
    /** Get the top element. */
    public int top() {
        while (q1.size() > 1) {
            q2.offer(q1.poll());
        }
        int x = q1.peek();
        q2.offer(q1.poll());
        while (!q2.isEmpty()) {
            q1.offer(q2.poll());
        }
        return x;
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q1.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

时间复杂度：入栈：O(1)；出栈：O(n)；返回栈顶元素：O(n)；判断空：O(1)

空间复杂度：O(n)

方法二：用一个队列实现栈

只定义一个队列，

当入栈时，将元素加入队列，并且将其倒置重新放入队列；

当出栈时，直接返回队首元素即可；

当返回栈顶元素时，直接返回队首元素即可；

当判断是否为空时，直接判断队列是否为空即可。

java：

class MyStack {

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

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

   }
   
   /** Push element x onto stack. */
   public void push(int x) {
       queue.add(x);
       int c = queue.size();
       while (c-- > 1) {
           queue.add(queue.poll());
       }
   }
   
   /** Removes the element on top of the stack and returns that element. */
   public int pop() {
       return queue.remove();
   }
   
   /** Get the top element. */
   public int top() {
       return queue.peek();
   }
   
   /** Returns whether the stack is empty. */
   public boolean empty() {
       return queue.isEmpty();
   }
}

/**
* Your MyStack object will be instantiated and called as such:
* MyStack obj = new MyStack();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.top();
* boolean param_4 = obj.empty();
*/

时间复杂度：入栈操作 O(n)，其余操作都是 O(1)

空间复杂度：O(n)，其中 n 是栈内的元素