（※）力扣刷题-栈和队列-用队列实现栈

news2024/9/24 15:29:02

255.用队列实现栈

使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素所以后面实现的时候会留下一个元素
top() – 获取栈顶元素
empty() – 返回栈是否为空
注意:
你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
你所使用的语言也许不支持队列。你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

思路

两个队列

队列模拟栈，其实一个队列就够了，那么我们先说一说两个队列来实现栈的思路。
队列是先进先出的规则，把一个队列中的数据导入另一个队列中，数据的顺序并没有变，并没有变成先进后出的顺序。
所以用栈实现队列，和用队列实现栈的思路还是不一样的，这取决于这两个数据结构的性质。
但是依然还是要用两个队列来模拟栈，只不过没有输入和输出的关系，而是另一个队列完全用来备份的！
如下面动画所示，用两个队列que1和que2实现栈的功能，que2其实完全就是一个备份的作用，把que1最后面的元素以外的元素都备份到que2，然后弹出最后面的元素，再把其他元素从que2导回que1。
可以自己画图分析下，更清晰

from collections import deque # python中使用collections中的deque

class MyStack(object):

    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):
        """
        :type x: int
        :rtype: None
        """
        # 直接append即可
        self.queue_in.append(x)


    def pop(self):
        """
        :rtype: 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 # 交换
        return self.queue_out.popleft()


    def top(self):
        """
        :rtype: int
        """
        """
        写法一：
        1. 首先确认不空
        2. 我们仅有in会存放数据，所以返回第一个即可（这里实际上用到了栈）
        写法二：
        1. 首先确认不空
        2. 因为队列的特殊性，FIFO，所以我们只有在pop()的时候才会使用queue_out
        3. 先把queue_in中的所有元素（除了最后一个），依次出列放进queue_out
        4. 交换in和out，此时out里只有一个元素
        5. 把out中的pop出来，即是原队列的最后一个，并使用temp变量暂存
        6. 把temp追加到queue_in的末尾
        """

        # 写法一
        # if self.empty():
        #     return None
        
        # return self.queue_in[-1] # 栈顶元素是队列最后一个元素 [-1]

        # 写法二
        if self.empty():
            return None
        
        temp = self.pop()
        self.queue_in.append(temp) # 只有in用来存数据  代码复用！
        return temp



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




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

优化：使用一个队列

from collections import queue
# 用一个队列
class MyStack(object):
    def __init__(self):
        self.queue = deque() # 使用双向队列的好处是两端都可以进/出元素
    
    def push(self, x):
        self.queue.append(x)
    
    def pop(self):
        if self.empty():
            return None
        for i in range(len(self.queue)-1):
            self.queue.append(self.queue.popleft()) # 注意一次循环只进行一次操作
        return self.queue.popleft()
    
    def top(self):
        temp = self.pop()
        self.queue.append(temp)
        return temp
    
    def empty(self):
        return len(self.queue) == 0