栈和队列

栈和队列基础（Python）

栈一种先进后出，队列先进后出。
Python中可以用list实现栈，用append()模拟入栈，用pop()模拟出栈。
也可以用list实现队列，但是效率较低，一般用collections.deque模拟（双端）队列。
5. 数据结构 — Python 3.11.5 文档

使用list进行栈的操作

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
stack
[3, 4, 5, 6, 7]
stack.pop()
7
stack
[3, 4, 5, 6]

使用collections.dequez进行队列操作

from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")           # Terry arrives
queue.append("Graham")          # Graham arrives
queue.popleft()                 # The first to arrive now leaves
'Eric'
queue.popleft()                 # The second to arrive now leaves
'John'
queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

232.用栈实现队列

#模拟
请你仅使用两个栈实现先入先出队列。

思路：
使用两个栈stackin和stackout分别进行入队和出队。
出队时，如果stackout为空，将stackin 倒入 stackout。

class MyQueue:def __init__(self):self.stackin  = []self.stackout = []def push(self, x: int) -> None:self.stackin.append(x)def pop(self) -> int:if self.empty():return Noneif not self.stackout:while self.stackin:self.stackout.append(self.stackin.pop())return self.stackout.pop()def peek(self) -> int:res = self.pop()self.stackout.append(res)return resdef empty(self) -> bool:return not (self.stackin or self.stackout)

225. 用队列实现栈

#模拟

重点还是pop。使用队列弹出元素时，需要先把之前的n-1个元素弹出，才能弹出第n个元素。
所以这里先弹出n-1个元素并添加到队列末尾，然后第n个元素就到了队列的开头。

这题没法仿照232的思路。注意队列和栈的区别，栈是反转元素进出顺序的，两次反转则变为先进先出。而队列是保持顺序的，进出两次队列后顺序不变。

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 Nonefor 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 Nonereturn self.que[-1]def empty(self) -> bool:return not self.que

20. 有效的括号

#栈
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串的括号是否有效。

栈的应用，使用栈来存储左括号，遇到右括号则弹出左括号进行匹配。

class Solution:def isValid(self, s: str) -> bool:stack = []d_k = {'(': ')', '{': '}', '[': ']'}for c in s:if c in  d_k.keys():stack.append(c)else:if len(stack) == 0:return Falseleft = stack.pop()if c != d_k[left]:return Falsereturn  len(stack) == 0

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

删除字符串的相邻重复字母，可以重复多次，直到没有没有相邻重复项。

#模拟 #栈

class Solution:def removeDuplicates(self, s: str) -> str:stack = []for c in s:if len(stack) > 0 and stack[-1] == c:stack.pop()else:stack.append(c)return "".join(stack)

150. 逆波兰表达式求值

#栈
逆波兰表达式又叫后缀表达式，运算符在操作数的后面，如：1 2 +
我们一般写的是中缀表达式，运算符在操作数的中间，如 ： 1 + 2
输入： tokens = [“2”,“1”,“+”,“3”,“*”]
输出： 9
解释： 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

借助栈，比较容易计算后缀表达式，遇到操作数就入栈，遇到运算符就弹出前面两个数，然后计算，并将计算结果入栈。

class Solution:def evalRPN(self, tokens: List[str]) -> int:stack = []res = 0for i in tokens:if i == '+' :a = stack.pop()b = stack.pop()stack.append(b+a)elif i == '-' :a = stack.pop()b = stack.pop()stack.append(b-a)elif i == '*' :a = stack.pop()b = stack.pop()stack.append(b*a)elif i == '/':a = stack.pop()b = stack.pop()stack.append(int(b/a))else :stack.append(int(i))return int(stack[-1])

看起来有点重复，可以简化一下：

class Solution:def evalRPN(self, tokens: List[str]) -> int:stack = []res = 0op_map = {'+': add, '-': sub, '*': mul, '/': lambda x, y: int(x / y)}for i in tokens:if i in op_map.keys():a = stack.pop() # 后b = stack.pop() # 前stack.append(op_map[i](b,a)) # 注意顺序 b op aelse :stack.append(int(i))return int(stack[-1])

239. 滑动窗口最大值

#单调队列 #队列
整体思路：希望有一个队列，在滑动窗口的时候，用push添加新的元素，用pop弹出被删除的元素，并且能直接获取队列的最大元素。
也就是说，我们希望实现一个队列存储可能成为窗口中最大值的元素。（称为单调队列）

1. 为了方便添加和删除元素，使用双端队列存储数据。
   self.queue = deque()
2. 添加操作 push： 添加元素value时，如果队列末尾比value小，就pop掉，然后添加value。（也就意味着，队列中的元素都比新加入的value大。push操作很关键，保证了队列中的元素是单调递减的，因此后面可以用self.queue[0]获取最大值）

def push(self, value):while self.queue and value > self.queue[-1]:# 队列末尾比value小则删除self.queue.pop() # pop，弹出队列末尾元素self.queue.append(value)

3. 删除操作 pop：删除元素value时，如果value等于队首元素que[0]，则弹出队首popleft()。

def pop(self, value):if self.queue and value == self.queue[0]:self.queue.popleft() # 弹出队首元素

获取最大值：

def front(self):return self.queue[0]

使用单调队列来解决滑动窗口最大值就比较简单了，不断地调用pop和push和 front。

class MyQueue:def __init__(self):self.queue = deque()# 删除value ，如果value 在队首则删除def pop(self, value):if self.queue and value == self.queue[0]:self.queue.popleft()# 添加value， valuea前面的比value小的都删除def push(self, value):while self.queue and value > self.queue[-1]:self.queue.pop()self.queue.append(value)def front(self):return self.queue[0]class Solution:def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:que = MyQueue()res = []for i in range(k):que.push(nums[i])res.append(que.front())for i in range(k, len(nums)):que.pop(nums[i-k])que.push(nums[i])res.append(que.front())return res

347.前 K 个高频元素

#优先级队列 #堆
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。

最容易想到的是用字典统计频率然后排序。

class Solution:def topKFrequent(self, nums: List[int], k: int) -> List[int]:mmap =  Counter(nums)sort = sorted(zip(mmap.values(),mmap.keys()), reverse=True)res = []for i in range(k):res.append(sort[i][1])return res

用堆排序，我们只需要维护一个大小为k的堆（优先级队列）。
在Python中可以用heapq或queue.PriorityQueue 实现。
heapq — 堆队列算法 — Python 3.11.5 文档
queue — 一个同步的队列类 — Python 3.11.5 文档

使用heapq

import heapq
class Solution:def topKFrequent(self, nums: List[int], k: int) -> List[int]:#要统计元素出现频率map_ = Counter(nums)#对频率排序#定义一个小顶堆，大小为kpri_que = [] #小顶堆#用固定大小为k的小顶堆，扫描所有频率的数值for key, freq in map_.items():heapq.heappush(pri_que, (freq, key))if len(pri_que) > k: #如果堆的大小大于了K，则队列弹出，保证堆的大小一直为kheapq.heappop(pri_que)#找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组result = [0] * kfor i in range(k-1, -1, -1):result[i] = heapq.heappop(pri_que)[1]return result

使用PriorityQueue

class Solution:def topKFrequent(self, nums: List[int], k: int) -> List[int]:#要统计元素出现频率map_ = Counter(nums)#对频率排序from queue import PriorityQueue as PQpri_que = PQ(k+1) #优先级队列(相当于小根堆)， 最多放k+1个元素#用固定大小为k的小顶堆，扫描所有频率的数值for key, freq in map_.items():pri_que.put((freq, key))if pri_que.qsize() > k:pri_que.get()print(pri_que.queue)#找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组result = [0] * kfor i in range(k-1, -1, -1):result[i] = pri_que.get()[1]return result

栈和队列小结

栈主要用来处理相邻匹配问题，队列可以处理滑动窗口的最值问题（单调队列，前k个最值问题（优先级队列/小根堆）。

python中栈可以用list实现，队列用colelctions.deque实现。

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
stack.pop()

import collections
queue = collections.deque()
queue.append(1) # 入队
queue.append(2)
queue.popleft() # 出队

此外还用到了优先级队列（堆），默认实现的是小根堆（堆顶元素最小）。

import heapq
pri_que = [] #小顶堆
heapq.heappush(pri_que, 1) # 入队
heapq.heappush(pri_que, 2)
heapq.heappop(pri_que) # 出队