用栈实现队列

使用栈实现队列的下列操作：
push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。
示例:
MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);
queue.peek(); // 返回 1
queue.pop(); // 返回 1
queue.empty(); // 返回 false
说明:
你只能使用标准的栈操作 -- 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）。

解法 1

利用两个栈，分别为输入栈和输出栈，队列的输入元素全部压入输入栈，当队列弹出或查看元素时，若输出栈为空，则将输入栈全部压入输出栈，此时已完成所有元素的倒序排列，返回输出栈的栈顶元素即可；若输出栈不为空，则直接返回输出栈的栈顶元素。

from collections import deque


class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.input_stack = deque()
        self.output_stack = deque()

    def push(self, x: int) -> None:
        """
        Push element x to the back of queue.
        """
        self.input_stack.append(x)

    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        if not self.output_stack:
            while not self.input_stack:
                self.output_stack.append(self.input_stack.pop())
        return self.output_stack.pop()

    def peek(self) -> int:
        """
        Get the front element.
        """
        if not self.output_stack:
            while not self.input_stack:
                self.output_stack.append(self.input_stack.pop())
        if not self.output_stack:
            return None
        return self.output_stack.__getitem__(-1)

    def empty(self) -> bool:
        """
        Returns whether the queue is empty.
        """
        return not self.input_stack and not self.output_stack

执行用时 :40 ms
内存消耗 :13.7 MB

时间复杂度：每个完成入队、出队的元素平均经历两次压入栈，两次弹出栈，时间复杂度都为 O(1)，取队首元素、判断空则对应栈的索引和判断空操作，时间复杂度也都为 O(1)
空间复杂度：入队、出队操作需要分别使用输入和输出两个栈，所以空间复杂度为 O(n)，取队首元素、判断空操作的空间复杂度为 O(1)

解法 2

利用两个栈，分别为存储栈和过渡栈，队列输入元素时，提前将存储栈元素全部压入过渡栈，然后输入元素压入存储栈，再将过渡栈元素全部弹出并放回存储栈，这样就将新元素排列了到栈底，实现了队列先入后出的效果。

from collections import deque


class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.store_stack = deque()
        self.tmp_stack = deque()

    def push(self, x: int) -> None:
        """
        Push element x to the back of queue.
        """
        while self.store_stack:
            self.tmp_stack.append(self.store_stack.pop())
        self.store_stack.append(x)
        while self.tmp_stack:
            self.store_stack.append(self.tmp_stack.pop())

    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        return self.store_stack.pop()

    def peek(self) -> int:
        """
        Get the front element.
        """
        if not self.store_stack:
            return None
        return self.store_stack.__getitem__(-1)

    def empty(self) -> bool:
        """
        Returns whether the queue is empty.
        """
        return not self.store_stack

执行用时 :40 ms
内存消耗 :13.7 MB

时间复杂度：每个完成入队的元素平均经历三次压入栈，两次弹出栈，时间复杂度为 O(n)，出队、取队首元素、判断空则对应栈的弹出、索引和判断空操作，时间复杂度都为 O(1)
空间复杂度：入队操作需要使用过渡栈，所以空间复杂度为 O(n)，出队、取队首元素、判断空操作的空间复杂度为 O(1)

注：解法 2 将主要工作放在了入队步骤，而解法 1 则将工作分摊在入队和出队两个步骤，平均性能更好。

参考

https://leetcode-cn.com/problems/implement-queue-using-stacks/