研习代码 day11 | 队列的应用——单调队列 && 优先级队列

本文链接：https://blog.csdn.net/pilgalaxy/article/details/133957207

一、滑动窗口最大值

1.1 题目

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

示例 2：

输入：nums = [1], k = 1
输出：[1]

提示：

1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length

1.2 题目链接

239.滑动窗口最大值

1.3 解题思路和过程想法

（1）解题思路：

基于普通的利用队列滑动窗口来筛选最大值的整体时间复杂度为 O(k * n)，答案会提示超时；进而做出修改：创建一个只维系可能是最大值元素的单调队列，使目前滑动窗口的最大值只出现在队列的出口处。
pop( ) ：要弹出的数值==等于队列最前的数值（即为最大值），则弹出队列最前的数值。
push( )：当传入的数值 > 队列入口处的数值，则弹出入口处比传入的值更小的值（只维护可能的最大值），最后将当前数字入队。

（2）过程想法：

最初想的是用两次遍历，外层遍历整个数组，内层再用一层遍历得出当前窗口的最大值，但是提示超时。后续改用卡哥提出的单调队列：只保留可能的最大值于出口处，比其小的数只可能存在于前者后面。只是在暴力解法的基础上，为降低获取最大值的时间复杂度，修改了存储滑动窗口的队列以及对入队和出队操作进行了剪枝。（刚开始有点不理解，花了点时间思考）

1.4 代码

# 使用列表来筛选元素的时间复杂度----O(n)，只能考虑使用 deque
from collections import deque

class myQueue:
  # 单调队列，只维护可能是最大值的元素，队列最前端的数值最大：
  def __init__(self):
    self.queue = deque()

  def pop(self,value):
    # 要弹出的数值==等于队列最前的数值（即为最大值），则弹出队列最前的数值
    if self.queue and value == self.queue[0]:
      self.queue.popleft()

  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]:
      # 基于普通的利用队列滑动窗口来筛选最大值的整体时间复杂度为 O(k * n)，答案会提示超时
      # 做出修改：创建一个只维系可能是最大值元素的单调队列，使目前滑动窗口的最大值只出现在队列的出口处
      length = len(nums)
      que = myQueue()
      res = []
      # 将前 k 个元素入队，并获取当前滑动窗口的最大值
      for i in range(k):
        que.push(nums[i])
      res.append(que.front())

      for i in range(k,length):
        # 出队原滑动窗口内元素
        que.pop(nums[i-k])
        # 入队新滑动窗口内元素
        que.push(nums[i])
        # 获取当前滑动窗口的最大值
        res.append(que.front())
      return res

二、前 K 个高频元素

2.1 题目

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

1 <= nums.length <= 10^5
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

进阶：你所设计算法的时间复杂度必须优于 O(n log n) ，其中 n 是数组大小。

2.2 题目链接

347.前 K 个高频元素

2.3 解题思路和过程想法

解题思路：

通过遍历全部元素，利用字典构建哈希结构记录词与词频的关系；通过遍历哈希表，利用小根堆来筛选出最大的 k 个值（选小根堆的原因：小根堆每次弹出的都是堆顶的最小元素，最终会剩下最大的 k 个值），但从小根堆的堆顶弹出的都是最小元素，所以最终逆序输出小根堆中的元素。

过程想法：

暴力解法是容易想到的，但是时间会超出限制；之前学过但没用过小根堆，所以之前没有思路。解锁新技能~

2.4 代码

import heapq

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        # 借助小根堆来筛选出最大的 k 个值(小根堆每次弹出的都是堆顶的最小元素)

        # 利用字典存储词与词频的对应关系
        hashTable = dict()
        length = len(nums)
        # 存储小根堆的结构
        last_k = []
        # 存储最后结果
        res = [0] * k

        # 建立词与词频的关系
        for i in range(length):
            hashTable[nums[i]] = hashTable.get(nums[i],0) + 1

        # 建立小根堆，并只保留 k 个元素
        for key,value in hashTable.items():
            heapq.heappush(last_k,(value,key))
            if len(last_k) >k:
                    heapq.heappop(last_k)

        # 因为弹出的值是最小值，为符合题目要求，倒序输出小根堆的元素
        for i in range(k-1,-1,-1):
            res[i] = heapq.heappop(last_k)[1]

        return res