代码随想录算法训练营|Day 10

Day 10

理论基础

了解一下 栈与队列的内部实现机制，文中是以C++为例讲解的

文章讲解：https://programmercarl.com/栈与队列理论基础.html

232.用栈实现队列

题目链接/文章讲解/视频讲解：https://programmercarl.com/0232.用栈实现队列.html

两个栈（n.）：入栈 出栈

弹出时： 出栈为空，将入栈所有元素弹到出栈；否则，弹出出栈中元素

peek:查询最顶上数值 代码复用，先pop再push

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:
            while self.stack_in:
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()
        
    def peek(self) -> int:
        res = self.pop()
        self.stack_out.append(res)
        return res
        
    def empty(self) -> bool:
        return not (self.stack_in or self.stack_out)

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

225. 用队列实现栈

题目链接/文章讲解/视频讲解：https://programmercarl.com/0225.用队列实现栈.html

队列里有size个元素，出(size-1)个元素再把它们都入进队列，再出来的那个元素就ok

💡

deque（全称：double-ended queue，双端队列）是 Python 标准库中 collections 模块提供的一个高效容器类型。它支持在两端快速地插入和删除元素，常见用法和特点如下：

• 导入与创建

  from collections import deque
  
  # 创建一个空 deque
  dq = deque()
  
  # 从可迭代对象初始化
  dq2 = deque([1, 2, 3, 4])
  
  

• 主要方法

  方法	功能说明
  append(x)	在右端（right）加入元素 x（时间复杂度 O(1)）
  appendleft(x)	在左端（left）加入元素 x（时间复杂度 O(1)）
  pop()	删除并返回右端元素（O(1)）
  popleft()	删除并返回左端元素（O(1)）
  extend(iterable)	在右端依次加入 iterable 中的所有元素
  extendleft(iterable)	在左端依次加入 iterable 中的所有元素（注意顺序会被反转）
  rotate(n=1)	将 deque 中的元素向右循环移动 n 步；负数向左移动
  clear()	清空所有元素
  maxlen 属性	若在创建时指定 maxlen，则达到该长度后继续添加会自动在另一端丢弃元素

• 固定长度双端队列

  # 最多只保留 3 个元素，超过后自动丢弃最左端
  dq = deque(maxlen=3)
  for i in range(5):
      dq.append(i)
      print(dq)
  # 输出：
  # deque([0], maxlen=3)
  # deque([0, 1], maxlen=3)
  # deque([0, 1, 2], maxlen=3)
  # deque([1, 2, 3], maxlen=3)
  # deque([2, 3, 4], maxlen=3)
  
  

• 性能特点

  • 高效的两端操作：相比于 Python 内置的 list，在队首插入或删除元素的操作是 O(1) 而非 O(n)；在队尾操作两者都是 O(1)。
  • 线程安全（thread-safe）：单个 append／pop 操作在多线程环境中是安全的，但复杂组合操作仍需自行加锁。
  • 支持随机访问：可以像列表那样使用索引 dq[i]，但这种操作时间复杂度为 O(n)，不推荐频繁使用。

• 典型应用场景

  1. 广度优先搜索（BFS, Breadth-First Search）中用作队列

     from collections import deque
     
     def bfs(graph, start):
         visited = set([start])
         queue = deque([start])
         while queue:
             node = queue.popleft()
             print(node)
             for nei in graph[node]:
                 if nei not in visited:
                     visited.add(nei)
                     queue.append(nei)
     
     

  2. 滑动窗口（sliding window）问题中保持固定长度缓存

  3. 实现栈（stack，也可使用 append + pop）或双端操作需求

• 示例

  from collections import deque
  
  dq = deque()
  dq.append(1)          # deque([1])
  dq.appendleft(0)      # deque([0, 1])
  dq.extend([2, 3, 4])  # deque([0, 1, 2, 3, 4])
  dq.rotate(2)          # deque([3, 4, 0, 1, 2])
  print(dq.pop())       # 2，剩余 deque([3, 4, 0, 1])
  print(dq.popleft())   # 3，剩余 deque([4, 0, 1])
  
  

总结：collections.deque 提供了一个在两端插入、删除都非常高效的容器，适合需要队列（queue）、栈（stack）、滑动窗口（sliding window）等场景。

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 _ in range(len(self.que)-1):
            self.que.append(self.que.popleft())
        return self.que.popleft()
        
    def top(self) -> int:
        ans = self.pop()
        self.que.append(ans)
        return ans
        
    def empty(self) -> bool:
        return not self.que
        
# 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()

20. 有效的括号

题目链接/文章讲解/视频讲解：https://programmercarl.com/0020.有效的括号.html

遇到左括号，把右括号push入栈。

遇到右括号，开始pop出栈看是否相等

情况1: 发现了不匹配的，return false

情况2: 字符串遍历完，栈不为空，说明左括号多了，return false

情况3: 字符串没遍历完，栈就为空了，说明右括号多了，return false

为什么%2无法把左括号多了or右括号多了的情况排除：

如果多的数字是偶数个，那么就无法排除

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        if len(s) % 2 != 0:
            return False
        for i in range(len(s)):
            if s[i] == '(':
                stack.append(')')
            elif s[i] == '{':
                stack.append('}')
            elif s[i] == '[':
                stack.append(']')
            elif not stack or stack.pop() != s[i]:
                return False
        if stack:
            return False
        return True

1047. 删除字符串中的所有相邻重复项

栈的经典应用。

要知道栈为什么适合做这种类似于爱消除的操作，因为栈帮助我们记录了 遍历数组当前元素时候，前一个元素是什么

题目链接/文章讲解/视频讲解：https://programmercarl.com/1047.%E5%88%A0%E9%99%A4%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E7%9A%84%E6%89%80%E6%9C%89%E7%9B%B8%E9%82%BB%E9%87%8D%E5%A4%8D%E9%A1%B9.html

使用栈的原因：

需要数据结构帮我们记住遍历过的元素

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        for i in range(len(s)):
            if not stack:
                stack.append(s[i])
            else:
                if stack[-1] == s[i]:
                    stack.pop()
                else:
                    stack.append(s[i])
        
        return ''.join(stack)  

# 方法一，使用栈
class Solution:
    def removeDuplicates(self, s: str) -> str:
        res = list()
        for item in s:
            if res and res[-1] == item:
                res.pop()
            else:
                res.append(item)
        return "".join(res)  # 字符串拼接