队列Python(deque模块)详解，Day3（力扣239. 滑动窗口最大值，# 力扣347. 前 K 个高频元素）

力扣239. 滑动窗口最大值

思路：

1. 双指针法，思想简单，但是程序最终会超时

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        res = []
        slow,fast = 0,k
        while fast <= len(nums):
            res.append(max(nums[slow:fast]))
            slow+=1
            fast+=1
        return res

结果如图

2.单调栈操作
1. 调用队列，分别定义pop，push，front
2. pop，如果要pop的值等于队列最左边元素（滑动窗口的最大元素），则 弹出元素。
3. push，首先将要进栈的元素与前边的元素比较，如果小于value的话就pop前面的元素，直到前面没有比value小的元素。然后再将value加入
4. front，即取队列最左边的元素，就是每次滑动窗口的最大值
5. 循环遍历数组，依次执行三个操作，将每次的front值记录到一个数组

Python代码

from collections import deque
class Queue:
    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 = Queue()
        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

力扣347. 前 K 个高频元素

思路

1. 首先计算所有元素的出现频率，用字典来记录，时间复杂度O(n)。
2. 然后用最小堆进行排序。

这里用到的是最小堆，堆是一种效率最高的优先级队列，那么先来看看什么是优先级队列：

优先级队列虽然也叫队列，但是和普通的队列还是有差别的。普通队列出队顺序只取决于入队顺序，而优先级队列的出队顺序总是按照元素自身的优先级。换句话说，优先级队列是一个自动排序的队列。元素自身的优先级可以根据入队时间，也可以根据其他因素来确定，因此非常灵活。

优先级队列的内部实现有很多种，例如有序数组、无序数组和堆等。但是无论哪种实现，优先级队列必须实现以下两种方法：insert和delete。insert方法是将带优先级的元素插入优先级队列中；delete方法是从优先级队列中取出最高优先级（或最低优先级）的元素并在队列中删除该元素（类似队列的出队）

即，优先级队列入队时，每个元素带有某种优先级信息，出队时，删除优先级最高的元素。普通队列可以看作以入队时间为优先级的优先级队列（入队越早，优先级越高）。

有序数组和无序数组可以看作优先级队列的一种，其优先级是元素的值。堆也是一种优先级队列。

什么是堆？
堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：
（1）堆中某个结点的值总是不大于或不小于其父结点的值；
（2）堆总是一棵完全二叉树。
将根结点最大的堆叫做最大堆，根结点最小的堆叫做最小堆。
堆的插入和删除元素的时间复杂度都是O(log(n))，因为涉及到元素的上浮和下沉操作，对于一个完全二叉树来说，若一共有n个元素，该树的高度就是log(n)。

说回题目：

首先我们明确，要使用大顶堆还是小顶堆？

要用小顶堆。因为要统计最大的前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。当然，我们最后输出结果的时候，要逆序输出。

由于堆中插入元素和删除元素的时间复杂度都是O(log(n))，这里维护的是k个元素的堆，所以一次操作的时间复杂度是O(log(k))，由于要遍历所有元素，因此完整的时间复杂度是O(nlog(k))。算上计算频率的时间复杂度，总复杂度是O(n)+O(nlogk)，仍为O(nlogk)。

具体实现上，统计完元素频率后，不断将频率压入堆中，当堆中的元素数量大于k了，就弹出堆顶元素。这样到最后留下的就是k个最大的元素。

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
        small_que = []
        for key,value in map_.items():
            heapq.heappush(small_que,(value,key))
            if len(small_que)>k:
                heapq.heappop(small_que)
        result = [0]*k
        for i in range(k):
            result[i] = heapq.heappop(small_que)[1]
        return result[::-1]