LeetCode Day9|232.用栈实现队列、225.用队列实现栈

题目链接：Loading Question... - 力扣（LeetCode）

思路：

首先明确栈是先入后出，后入先出的结构，元素从同一口出入；而队列是先入先出，后入后出的结构，队列中的元素从队尾进队头出。二者在本质上是不同的。在python中，可以用list结构来充当栈的结构，用list的append()和pop()分别模拟栈的push()和pop()操作。

定义两个栈分别充当入栈(stack_in)和出栈(stack_out)；在push时将元素append放入入栈中完成入队操作；在pop时当出栈不为空则对出栈进行pop操作完成出队操作，当出栈为空则先将入栈中的元素依次取出放入出栈中，再对出栈进行pop

peek()返回队列开头的元素，即读取却不删除队头的元素，可以先用一个中间变量来存储pop操作返回的此元素，再将此元素存入到出栈当中，即完成了peek()操作

class MyQueue:

    def __init__(self):
        """
        in主要负责push，out主要负责pop
        """
        self.stack_in = []
        self.stack_out = []


    def push(self, x: int) -> None:
        """
        有新元素进来，就往in里面push
        """
        self.stack_in.append(x)


    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        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:
        """
        Get the front element.
        """
        ans = self.pop()
        self.stack_out.append(ans)
        return ans


    def empty(self) -> bool:
        """
        只要in或者out有元素，说明队列不为空
        """
        return not (self.stack_in or self.stack_out)

题目链接：225. 用队列实现栈 - 力扣（LeetCode）

思路：

本题若想用同样的思维，用两个队列将元素的顺序反转过来，进而完成栈的功能是不正确的，因为队列中的元素按顺序出队再进入下一个队列顺序是不变的。

故而本题中的另一个队列的作用是为第一个队列进行备份，在完成“出栈”操作之前，为暂时出队却实际上不“出栈”的元素做备份，在最后一个元素完成“出栈”之后，再将备份的元素按照顺序一一还原到原队列中。

此题的另一个解题思路只需要用到一个队列，在“出栈”操作完成之前，只需要将出队的元素全部按照顺序再从队尾入队即可，直到该“出栈”的元素完成“出栈”或出队。

# 用两个队列完成
from collections import deque

class MyStack:

    def __init__(self):
        """
        Python普通的Queue或SimpleQueue没有类似于peek的功能
        也无法用索引访问，在实现top的时候较为困难。

        用list可以，但是在使用pop(0)的时候时间复杂度为O(n)
        因此这里使用双向队列，我们保证只执行popleft()和append()，因为deque可以用索引访问，可以实现和peek相似的功能

        in - 存所有数据
        out - 仅在pop的时候会用到
        """
        self.queue_in = deque()
        self.queue_out = deque()

    def push(self, x: int) -> None:
        """
        直接append即可
        """
        self.queue_in.append(x)


    def pop(self) -> int:
        """
        1. 首先确认不空
        2. 因为队列的特殊性，FIFO，所以我们只有在pop()的时候才会使用queue_out
        3. 先把queue_in中的所有元素（除了最后一个），依次出列放进queue_out
        4. 交换in和out，此时out里只有一个元素
        5. 把out中的pop出来，即是原队列的最后一个
        
        tip：这不能像栈实现队列一样，因为另一个queue也是FIFO，如果执行pop()它不能像
        stack一样从另一个pop()，所以干脆in只用来存数据，pop()的时候两个进行交换
        """
        if self.empty():
            return None

        for i in range(len(self.queue_in) - 1):
            self.queue_out.append(self.queue_in.popleft())
        
        self.queue_in, self.queue_out = self.queue_out, self.queue_in    # 交换in和out，这也是为啥in只用来存
        return self.queue_out.popleft()

    def top(self) -> int:
        """
        1. 首先确认不空
        2. 我们仅有in会存放数据，所以返回第一个即可
        """
        if self.empty():
            return None
        
        return self.queue_in[-1]


    def empty(self) -> bool:
        """
        因为只有in存了数据，只要判断in是不是有数即可
        """
        return len(self.queue_in) == 0

# 用一个队列完成
class MyStack:

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

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

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

    def top(self) -> int:
        if self.empty():
            return None
        return self.que[-1]

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