代码营打卡Day13

1. 滑动窗口最大值(239)

单调队列的经典题目

滑动窗口移动的时候, 从滑动窗口来说要pop掉一个元素, 并且push进一个元素. 如果这个pop掉元素刚好是单调队列中的front元素(即最大值), 那么将que中的front元素给pop掉. 加入一个元素时, 检查这个元素和栈尾(back)元素的大小, 如果这个元素大于back的元素, 就把小于它的back元素全部弹出

class MyQueue { //单调队列（从大到小）
public:
    deque<int> que; // 使用deque来实现单调队列
    // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
    // 同时pop之前判断队列当前是否为空。
    void pop(int value) {
        if (!que.empty() && value == que.front()) {
            que.pop_front();
        }
    }
    // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
    // 这样就保持了队列里的数值是单调从大到小的了。
    void push(int value) {
        while (!que.empty() && value > que.back()) {
            que.pop_back();
        }
        que.push_back(value);

    }
    // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
    int front() {
        return que.front();
    }
};

伪代码如上, python实现的时候注意, 弹出队列左边元素用

queue.popleft()

右边元素直接用pop(), 即对应pop_back()

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(object):
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: 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

 2. 前k个高频元素(347)

这道题就是给一个数组, 统计每个数的出现的次数, 然后取前k个高频出现的数

这道题可以用map, key记录元素, value记录元素出现的个数 , 然后把map中的元素做遍历排序, 然后取出前k个高频元素

考虑用小顶堆存储还是大顶堆, 都是二叉树的方式, 小顶堆的根节点是最小的元素, 大顶堆的根节点是最大的元素, 要注意对于大顶堆每次pop都pop掉了最上面的即最大元素, 显然是不符合要求的, 所以采取小顶堆来存储前k个元素, 那么复杂度就由 nlogn变成了nlogk, 因为顶堆只维护k个元素

遍历到就push到顶堆中, 超了k就pop掉, 最后注意要从大到小, 所以要逆向输出

import heapq
class Solution(object):
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        map1 = {}
        for i in range(len(nums)):
            map1[nums[i]] = map1.get(nums[i], 0) + 1
        
        pri_que = []

        for key, freq in map1.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

 heapq是python标准库中的一个模块, 提供了一些堆队列的算法, 也称为优先队列算法, 堆是一种特殊的树结构. heapq模块实现了一个最小堆.

heapq.heappush(heap, item) 函数将元素 item 添加到堆 heap 中，同时保持堆的性质。堆的性质是指堆中的每个节点都小于或等于其子节点，这样可以确保最小的元素始终位于堆的根节点。

要注意排序时要把freq放在前面

附上另一种用字典的解法:

    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        # 使用字典统计数字出现次数
        time_dict = defaultdict(int)
        for num in nums:
            time_dict[num] += 1
        # 更改字典，key为出现次数，value为相应的数字的集合
        index_dict = defaultdict(list)
        for key in time_dict:
            index_dict[time_dict[key]].append(key)
        # 排序
        key = list(index_dict.keys())
        key.sort()
        result = []
        cnt = 0
        # 获取前k项
        while key and cnt != k:
            result += index_dict[key[-1]]
            cnt += len(index_dict[key[-1]])
            key.pop()

        return result[0: k]

首先以key为数字元素, 以value为出现次数, 统计每个元素出现次数

然后在index_dict字典中翻转, 以出现次数(频率)作为key值, 将value作为之前的数字元素, 并且一个频率key可以对应多个不同的元素value, 比如index_dict = { 1: [3], 2: [2], 3: [1, 4, 5] }

然后就是用频率key进行从小到大的排序, 每次都将当前频率最大的(即排序后的key的倒数第一位对应的元素放入result中), 并用cnt计数, 每次增加一个key多对应的value长度的值, 直到总和大于等于k. 完成以后弹出最大的元素(pop弹出最后一个元素)并继续操作

最后取result的前k个元素