代码随想录打卡（12 ）—— 栈与队列（滑动窗口和优先级队列（堆的使用））

力扣239.滑动窗口最大值

用单调队列模拟滑动窗口：（左出右进）每压入一个值，对比其与前面已压入的值的大小，如比前面（左边）的值小则接入后面（相当于创建滑动窗口），如比前面的值大，则该值应为目前压入窗口的最大值，则pop出前面较小的值。因此，单调队列中保留的值均为由大（左）到小（右），当个数满足滑动窗口要求的大小k时，返回最前面（左边）即为窗口内最大值。

class Solution:
    
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        class MyQueue: #单调队列（从大(左)到小（右）)
            def __init__(self):
                self.queue = deque() #这里需要使用deque实现单调队列，直接使用list会超时
        
            #每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
            #同时pop之前判断队列当前是否为空。
            def pop(self, value):
                if self.queue and value == self.queue[0]:
                    self.queue.popleft() #list.pop()时间复杂度为O(n),这里需要使用collections.deque()
                
        #如果push的数值大于入口元素的数值，那么就将队列后端（出口）的数值弹出，直到push的数值小于等于队列入口元素的数值为止。（左出右进）
        #这样就保持了队列里的数值是单调（出口到入口，）从大到小的了。
            def push(self, value):
                while self.queue and value > self.queue[-1]: 
                    self.queue.pop()
                self.queue.append(value)
            
        #查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
            def front(self):
                return self.queue[0]

        que = MyQueue()
        result = []
        for i in range(k): #先将前k的元素放进队列
            que.push(nums[i])
        result.append(que.front()) #result 记录前k的元素的最大值
        for i in range(k, len(nums)): # 模拟滑动
            que.pop(nums[i - k]) #滑动窗口移除最前面（左：出口）元素
            que.push(nums[i]) #滑动窗口前加入（右：小则加，大则pop前一元素后加入）最后面的元素
            result.append(que.front()) #记录对应的最大值
        return result

力扣347.前K个高频元素

对堆类型不太熟悉，用法参照heapq --- 堆队列算法 — Python 3.11.1 文档

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        #时间复杂度：O(nlogk)
        #空间复杂度：O(n)
        import heapq （堆）
        #要统计元素出现频率
        map_ = {} #nums[i]:对应出现的次数
        for i in range(len(nums)):
            map_[nums[i]] = map_.get(nums[i], 0) + 1  # 如果指定键不存在，默认按照get(key,val)中val的值赋予该键
        
        #对频率排序
        #定义一个小顶堆，大小为k（根小枝大）
        pri_que = [] #小顶堆
        
        #用固定大小为k的小顶堆，扫描所有频率的数值
        for key, freq in map_.items():
            heapq.heappush(pri_que, (freq, key)) # 将 （freq，key） 的元组加入 heap 中，保持堆的不变性。
            if len(pri_que) > k: #如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                heapq.heappop(pri_que) # 弹出并返回 heap 的最小的元素，保持堆的不变性。如果堆为空，抛出IndexError
        
        #找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        result = [0] * k
        for i in range(k-1, -1, -1):
            result[i] = heapq.heappop(pri_que)[1] # 元组内第一个值为key
        return result