代码随想录算法训练营 Day13｜239. 滑动窗口最大值, 347.前 K 个高频元素

Day13｜239. 滑动窗口最大值, 347.前 K 个高频元素

239. 滑动窗口最大值

思路

没太有思路，不知道应该用什么样的思维和技巧去做题。

看代码随想录视频，该题为队列的应用，需要构造单调队列。
遍历一遍数组，每次将滑动窗口不需要的值pop，然后push新的值，每次求队列中的最大值。

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        def getMax(queue):
            maximum = float('-inf')
            for i in queue:
                if i > maximum:
                    maximum = i
            return maximum

        queue = deque([])
        maximum = []
        for i in range(k):
            queue.append(nums[i])
        maximum.append(getMax(queue))
        for i in range(k, len(nums)):
            queue.popleft()
            queue.append(nums[i])
            maximum.append(getMax(queue))
        return maximum

问题：
测试用例通过，但整体超出时间限制。
该方法相当于暴力解法，并不是视频中所说的单调队列。

构造单调队列解法
首先，需要自己构造一个单调队列。
关键点在于，如何维护这个单调队列。
规则：

1. push进队列的元素，如果该元素比前面的所有元素都大，则将前面的元素全部pop
2. 此时，最大值一直保持为队列顶端（出口处）的元素

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]:
        que = MyQueue()
        result = []
        for i in range(k): 
            que.push(nums[i])
        result.append(que.front()) 
        for i in range(k, len(nums)):
            que.pop(nums[i - k])
            que.push(nums[i]) 
            result.append(que.front()) 
        return result

总结

写代码的时候没想到要用class去构造一个单调队列，甚至包括push，pop等方法也要重新构造。
之后需要再自己写一遍

Python:整数的最大值和最小值

max_value = float(‘inf’)
min_value = float(‘-inf’)

347.前 K 个高频元素

思路

学习什么是“堆”
题目需要对频率进行排序，这里可以使用容器适配器：优先级队列。
优先级队列就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。

用python实现堆
在 Python 中，堆通常通过 heapq 模块来实现。heapq 提供了一些堆操作的函数，用于在列表上实现堆的行为。

1. 创建堆：
   heapq.heapify(iterable): 将可迭代对象（如列表）转换为堆。
2. 堆的基本操作：
   heapq.heappush(heap, elem): 将元素添加到堆中。
   heapq.heappop(heap): 弹出并返回堆中的最小元素。

import heapq
class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        map_ = {} 
        for i in range(len(nums)):
            map_[nums[i]] = map_.get(nums[i], 0) + 1
        pri_que = [] 
        for key, freq in map_.items():
            heapq.heappush(pri_que, (freq, key))
            if len(pri_que) > k: 
                heapq.heappop(pri_que)
        result = [0] * k
        for i in range(k-1, -1, -1):
            result[i] = heapq.heappop(pri_que)[1]
        return result