2025/3/2 【栈与队列】LeetCode225.用队列实现栈 【√】

自己写的：

类似用两个栈实现队列的那道题，只要简单的转换一下思路，在脑子里模拟一下用两个队列配合表现出一个栈的功能。

from collections import deque
class MyStack:

    def __init__(self):
        # 两个队列，相当于两个篮子
        self.deque1 = deque()
        self.deque2 = deque()

    def push(self, x: int) -> None:
        # 如果两个队列篮子都是空的，把数放到第一个队列中
        if self.empty():
            self.deque1.append(x)
        
        # 如果队列1不空，队列2空，则把数放到第1个队列中
        elif self.deque1 and (not self.deque2):
            self.deque1.append(x)
        
        # 反之
        else:
            self.deque2.append(x)
        
    def pop(self) -> int:
        # 先判空
        if self.empty():
            return None
        
        # 如果队列1空，2不空，则把队列2最后一个数前面的所有数放到队列1中，
        # pop队列2剩下的最后一个元素
        if not self.deque1 and self.deque2:
            for i in range(len(self.deque2)-1):
                self.deque1.append(self.deque2.popleft())
            
            ans = self.deque2.popleft()
            return ans
        
        # 反之
        else:
            for i in range(len(self.deque1)-1):
                self.deque2.append(self.deque1.popleft())
            
            ans = self.deque1.popleft()
            return ans     

    def top(self) -> int:
        # 先pop出来，再push回去
        ans = self.pop()
        self.push(ans)  
        return ans

    def empty(self) -> bool:
        # 如果队列1和2都为空，才返回true
        return not(self.deque1 or self.deque2)
        


# 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()

 方法2：两个队列实现一个栈（来自代码随想录）

我的方法需要判断当前的情况是哪个队列作为主要存储数据的篮子，哪个作为备选篮子。

代码随想录的方法在pop函数中，把queue_in中最后一个数前面的所有数逐个添加到queue_out后，会交换in和out，从而不需要判断哪个是备选的篮子。

代码就更加简洁。

from collections import deque
class MyStack:

    def __init__(self):
        # 两个队列，相当于两个篮子
        self.queue_in = deque()
        self.queue_out = deque()

    def push(self, x: int) -> None:
        self.queue_in.append(x)
        
    def pop(self) -> int:
        if self.empty():
            return None
        
        for _ 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
        return self.queue_out.popleft()

    def top(self) -> int:
        ans = self.pop()
        self.queue_in.append(ans)
        return ans
        
    def empty(self) -> bool:
        return not self.queue_in
        

方法3：单个队列实现栈的功能

from collections import deque
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
        
        n = len(self.queue)
        for i in range(n-1):
            self.queue.append(self.queue.popleft())
        
        return self.queue.popleft()

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