力扣Day10（2.13）| 第五章 队列 （232. 用栈实现队列 225. 用队列实现栈 ）抄写，均需重新独立完成

题一：232. 用栈实现队列

链接

题目链接：
视频链接：
文章链接：

视频总结

关键点

1. 双栈实现队列
2. 栈先进后出
3. 队列先进先出
4. 函数的复用在工业界很重要（回想阿改美妙的复用），因为当这些函数需要修改时，如果不是复用而是粘贴了过去，则所有调用过的地方都需要改变，但是不可能粘贴一词就记录其位置，所以复用调用的思路强大的多，否则项目的定时炸弹很多

力扣实战

思路一：

 class MyQueue:
        #本题只作为学习和注释，跟着敲一遍代码，以后还需独立重写
    def __init__(self):
        # in负责push out负责pop
        self.stack_in = []  #此时这两行左边的都是数组名，
        self.stack_out = []

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


    def pop(self) -> int:
        # 删除队列开头的元素并且返回，先需要判断in里面是不是空，不是需要一直输到out里，为空后再返回out里的第一个即可
        if self.empty():    # 若队列就是为空则none，表示非法操作
            return None
        if self.stack_out:  # 第一次判断若out是空，此时把所有的in加入out，如果不是空，则说明此时in里已经全部被加入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:
        result = self.pop() # 函数调用而不是cv，这样提高工业稳定性
        self.stack_out.append(result)
        return result


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



# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()
        
# 反思1：

题二：225. 用队列实现栈

链接

题目链接：
视频链接：
文章链接：

视频总结

卡尔：

1.一个队列实现的思路：先把前面的弹出再加入，再弹出

力扣实战

思路一：

 #双队列，则第二个队列知识用来备份
 from collections import deque

class MyStack:

    def __init__(self):
        self.q1=deque()
        self.q2 = deque()


    def push(self, x: int) -> None:
        self.q1.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
        else:
            for i in range(len(self.q1)-1):
                self.q2.append(self.q1.popleft)
            self.q1,self.q2 = self.q2,self.q1
            return self.q2.popleft()


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


    def empty(self) -> bool:
        if self.q1 or self.q2 :     # 因为只有in存了数据，只要判断in是不是有数即可 return len(self.queue_in) == 0
            return False
        else:
            return True



# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()
        
# 反思1：

思路二：

 # 使用一个队列来实现,和两个队列思路差不多，只不过双队列是备份然后互换，而单队列是直接插在后面，省去了一些步骤 ，主要在pop方法有区别，其他的差不多。
 from collections import deque

class MyStack:

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


    def push(self, x: int) -> None:
        self.q1.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
        else:
            for i in range(len(self.q1)-1):
                self.q1.append(self.q1.popleft())
            return self.q1.popleft()


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


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