代码随想录算法训练营第13天|栈与队列三|239.滑动窗口最大值|347.前K个高频元素

代码随想录算法训练营第13天|栈与队列三|239.滑动窗口最大值|347.前K个高频元素

一、239.滑动窗口最大值

文档链接：代码随想录

题目链接：239.滑动窗口最大值

视频讲解：视频讲解

题目描述：

给你一个整数数组 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 <= 105
• -104 <= nums[i] <= 104
• 1 <= k <= nums.length

代码：

• 双队列

思路：使用双端队列（deque）来维护滑动窗口内的元素，并保持队列的头部始终是窗口内的最大值。

1. 我们使用一个双端队列（deque）来存储当前滑动窗口中有可能成为最大值的元素的下标。
2. 我们从数组的第一个元素开始遍历数组，依次处理每一个元素。
3. 在处理每一个元素时，我们需要做以下操作：
   • 移除队首不在当前窗口内的元素：如果队列不为空且队首元素所对应的下标不在当前窗口范围内（即小于等于 i - k），则移除队首元素。
   • 移除队尾小于当前元素的元素：如果队列不为空且队尾元素对应的元素值小于当前元素的值 nums[i]，则移除队尾元素，因为当前元素成为了候选的最大值，之前的值已经没有意义。
   • 将当前元素下标加入队列尾部：将当前元素的下标 i 添加到队列的末尾，因为我们需要存储当前窗口范围内可能成为最大值的元素索引。
   • 如果当前窗口完整，即已经遍历到了可以形成长度为 k 的窗口时（即当 i >= k - 1）, 此时排队首元素所对应的值即为当前窗口的最大值。将排队首元素值添加到结果列表中。
4. 最终，返回结果列表。

from collections import deque
from typing import List
class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:      
        queue = deque()  # 双端队列
        result = []      # 结果列表
        
        for i in range(len(nums)):
            # 移除队首不在当前窗口内的元素
            if queue and queue[0] <= i - k:
                queue.popleft()
            
            # 移除队尾小于当前元素的元素
            while queue and nums[queue[-1]] < nums[i]:
                queue.pop()
            
            # 将当前元素下标加入队列尾部
            queue.append(i)
            
            # 如果当前窗口完整，则记录队首元素的值
            if i >= k - 1:
                result.append(nums[queue[0]])
        
        return result

二、347.前K个高频元素

文档链接：代码随想录

题目链接：347.前K个高频元素

视频讲解：视频讲解

题目描述：

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

示例 1:

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

示例 2:

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

提示：

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

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

代码：

思路：构建一个最小堆来找到数组中频率最高的k个元素。首先使用哈希表freq_map统计每个元素的出现频率，然后利用这些频率和元素值构建最小堆。在构建堆的过程中，如果堆的大小超过了k，则移除堆顶元素（即频率最低的元素）。最后，从堆中弹出k个元素，并返回这些元素组成的列表，按频率降序排列。

import heapq
from typing import List
class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        freq_map = {}     # 统计每个元素的出现频率
        # 遍历输入的nums列表，统计每个元素的出现频率
        for num in nums:
            # 如果num在freq_map中，则增加其对应的计数；否则，添加num到字典并设置计数为1 
            freq_map[num] = freq_map.get(num, 0) + 1

        minHeap = []  # 初始化一个空列表minHeap，用于构建最小堆，存储出现频率前k高的元素

        # 遍历freq_map中的每个元素及其频率，并将它们作为元组添加到最小堆中
        for num, count in freq_map.items():
            # 堆中的元素是元组，第一个元素是频率，第二个元素是数值，heapq.heappush用于将元素添加到堆中并保持堆的性质
            heapq.heappush(minHeap,(count,num)) 
            if len(minHeap) > k:
                # 如果堆的大小超过了k，则移除堆顶元素（即出现频率最低的元素）  
                heapq.heappop(minHeap)

        # 初始化一个空列表result，用于存储最终的答案
        result = []
        # 从最小堆中依次弹出元素，将元素值添加到结果数组中
        for _ in range(k):
            # heapq.heappop用于弹出堆顶元素，并返回该元素，由于堆中的元素是元组，我们使用[1]来获取元素值  
            result.append(heapq.heappop(minHeap)[1])

        # 由于堆是按照频率升序排列的，所以需要返回结果列表的反转，即得到按频率降序排列的结果
        return result[::-1]