【代码随想录day9】● 栈与队列理论基础 ● 232.用栈实现队列 ● 225. 用队列实现栈

栈与队列理论基础

栈：后入先出
队列：先入先出
其他略

232.用栈实现队列

问题

题目链接：https://leetcode.cn/problems/implement-queue-using-stacks/
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾 （其实就是入队列）
int pop() 从队列的开头移除并返回元素（出队列）
int peek() 返回队列开头的元素（返回队列最先进入的元素）
boolean empty() 如果队列为空，返回 true ；否则，返回 false

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。

示例：

[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解答

过程比较简单，用两个栈分别实现入队列和出队列就行。入队列的元素放在第一个栈，出队列时先把所有元素放入第二个栈，然后再出栈就模拟了队列。如果两个栈都为空，则队列为空。

因为栈先入后出，后入先出。先入第一个栈的会在栈底，因此进入第二个栈的时候最后进入，也就在栈顶了。然后出第二个栈的时候就会第一个出来，模拟了先入先出。

代码：

class MyQueue:

    def __init__(self):
        self.stack_in = []
        self.stack_out = []


    def push(self, x: int) -> None:
        self.stack_in.append(x)


    def pop(self) -> int:
        if self.empty():
            return None
        if self.stack_out:
            return self.stack_out.pop()
        else:
            for i in range(len(self.stack_in)):
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()


    def peek(self) -> int:
        ans = self.pop()
        self.stack_out.append(ans)
        return ans


    def empty(self) -> bool:
        return not (self.stack_in or self.stack_out)

pop():
如果队列为空则返回None
如果出栈（stack_out）不为空，则利用出栈，stack.pop()返回第一个元素。
如果出栈为空，则将入栈（stack_in）里所有元素放入出栈，然后再出栈。

peek():
先使用sefl.pop()，返回队列第一个元素，但此时原队列就少了一个元素，因此要加上。由于栈后入先出，因此只需要把这个元素再放在stack_out的栈顶就行，这样下次使用pop时，他还是第一个出队列。

225. 用队列实现栈

问题

题目链接：https://leetcode.cn/problems/implement-stack-using-queues/
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

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

示例：

[“MyStack”, “push”, “push”, “top”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解答

这个相比于上一题复杂一些，因为队列是先入先出，直接按照上题思路无法改变进出顺序，因此还要多一些步骤。

同样使用两个队列，在出栈时，将第一个队列里的元素依次出队列，放在第二个队列，最后一个元素不用放入，直接返回。然后将第二个队列里的元素再放回第一个队列。

代码：

class MyStack:

    def __init__(self):
        self.queue = deque()
        self.queue_store = deque()


    def push(self, x: int) -> None:
        self.queue.append(x)


    def pop(self) -> int:
        if self.empty():
            return None
        else:
            for i in range(len(self.queue)-1):
                self.queue_store.append(self.queue.popleft())
            ans = self.queue.pop()
            for i in range(len(self.queue_store)):
                self.queue.append(self.queue_store.popleft())
            return ans


    def top(self) -> int:
        ans = self.pop()
        self.queue.append(ans)
        return ans


    def empty(self) -> bool:
        return  not self.queue

注意初始化要用queue = deque（），其次队列的pop使用popleft，否则就和list一样了（后入先出），而不是先入先出了。

优化一下：

class MyStack:

    def __init__(self):
        self.queue = deque()
        self.queue_store = deque()


    def push(self, x: int) -> None:
        self.queue.append(x)


    def pop(self) -> int:
        if self.empty():
            return None
        else:
            for i in range(len(self.queue)-1):
                self.queue_store.append(self.queue.popleft())
            self.queue, self.queue_store = self.queue_store, self.queue # 交换queue和用于中转的queue
            return self.queue_store.popleft()


    def top(self) -> int:
        return self.queue[-1] # 直接返回[-1]就行


    def empty(self) -> bool:
        return  not self.queue

实际上只用一个队列就行，只要每次pop时再添加一下就行，最后输出最后一个元素：

class MyStack:

    def __init__(self):
        self.queue = deque()


    def push(self, x: int) -> None:
        self.queue.append(x)


    def pop(self) -> int:
        if self.empty():
            return None
        else:
            for i in range(len(self.queue)-1):
                self.queue.append(self.queue.popleft())
            return self.queue.popleft()


    def top(self) -> int:
        return self.queue[-1]


    def empty(self) -> bool:
        return  not self.queue