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

239. 滑动窗口最大值

思路：

这是使用单调队列的经典题目。

暴力方法，遍历一遍的过程中每次从窗口中再找到最大的数值，这样很明显是O(n × k)的算法。

有的同学可能会想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， 但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。

此时我们需要一个队列，这个队列呢，把窗口里的元素放进去，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么（即滑动窗口最大值）。

每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值。

然后再分析一下，队列里的元素一定是要排序的，而且要最大值放在出队口，要不然怎么知道最大值呢。但如果把窗口里的元素都放进队列里，窗口移动的时候，队列需要弹出元素。那么问题来了，已经排序之后的队列 怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢。

大家此时应该陷入深思.....

其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++、python中没有直接支持单调队列，需要我们自己来实现一个单调队列。不要以为实现的单调队列就是对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。

设计单调队列的时候，pop，和push操作要保持如下规则：

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止
3. 保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。

为了更直观的感受到单调队列的工作过程，以题目示例为例，输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3，动画如下： 

那么我们用什么数据结构来实现这个单调队列呢？

使用deque最为合适

扩展：

大家貌似对单调队列 都有一些疑惑，首先要明确的是，题解中单调队列里的pop和push接口，仅适用于本题哈。单调队列不是一成不变的，而是不同场景不同写法，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。 不要以为本题中的单调队列实现就是固定的写法哈。

代码：

from collections import deque

class MyQueue: # 创建单调队列(从大到小)
    def __init__(self): 
        self.queue=deque() # 这里使用deque实现单调队列

    def pop(self,value):
        if self.queue and value == self.queue[0]: #每次弹出的时候，比较当前要弹出的数值是否等于队列最前端元素的数值，如果相等则弹出
            self.queue.popleft() # popleft()移除队列最前端(出口)的元素，并且返回该元素的值
    
    def push(self,value):
        while self.queue and value > self.queue[-1]: # 如果添加的数值大于队列最后端(入口)的元素，那么就将队列最后端的元素弹出，直到添加的数值小于等于队列入口的元素为止。这样就保持了队列里的元素是单调从大到小的了
            self.queue.pop() # 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): # 先将nums前k个元素放进滑动窗口(队列)
            que.push(nums[i])
        result.append(que.front()) # 记录前k个元素的最大值

        for i in range(k, len(nums)):
            que.pop(nums[i - k]) # 移除滑动窗口最前端的元素
            que.push(nums[i]) # 在滑动窗口后端添加元素
            result.append(que.front()) # 记录当前滑动窗口(队列)的最大值
        
        return result

• 时间复杂度: O(n)
• 空间复杂度: O(k)

347.前 K 个高频元素 

思路：

这道题目主要涉及到如下三块内容：

1. 要统计元素出现频率
2. 对频率排序
3. 找出前K个高频元素

首先统计元素出现的频率，这一类的问题可以使用map来进行统计。

然后是对频率进行排序，这里我们可以使用一种容器适配器就是优先级队列。

优先级队列，其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。而且优先级队列内部元素是自动依照元素的权值排列

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

所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。

本题我们就要使用优先级队列来对部分(k个元素)频率进行排序。为什么不用快排呢， 使用快排要对整个数组进行排序（时间复杂度为nlogn）。而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。

这题我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

寻找前k个最大元素流程如图所示：（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描） 

代码：

import heapq

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        
        map = {} # 定义一个map统计数组各元素出现频率，key为元素，value为出现频率
        for i in range(len(nums)):
            map[nums[i]] = map.get(nums[i], 0) + 1

        #对每个元素出现的频率进行排序
        pri_que = [] # 定义一个小顶堆(优先级队列)，大小为k

        
        for key, value in map.items(): # 遍历以元组(里面是key和value)作为元素的列表
            heapq.heappush(pri_que, (value, key)) # heapq.heappush()是往堆中添加新值，此时自动建立了小顶堆(以value来进行堆排序)
            if len(pri_que) > k: #如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                heapq.heappop(pri_que) # heapq.heappop()是从堆中弹出并返回最小的值

        #找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        result = [0] * k
        for i in range(k-1, -1, -1):
            result[i] = heapq.heappop(pri_que)[1] # heapq.heappop(pri_que)得到的是一个元组，[1]表示取出元组的第二个元素，即key
        return result

• 时间复杂度: O(nlogk)，遍历一遍数组时间复杂度为n，堆中每加入一个元素时间复杂度为logk（k为堆的大小），所以时间复杂度为nlogk。如果数组集合很大且k比较小的情况，这个解法的时间复杂度明显优于把所有元素进行排序
• 空间复杂度: O(n)

补充：

1.Python字典 items() 函数作用：把字典中的每对key和value组成一个元组，并把这些元祖放在列表中返回

实例：

dict = {'老大':'15岁',
        '老二':'14岁',
        '老三':'2岁',
        '老四':'在墙上'
        }
print(dict.items())
for key,values in dict.items():
    print(key + '已经' + values + '了')

输出结果：

dict_items([('老大', '15岁'), ('老二', '14岁'), ('老三', '2岁'), ('老四', '在墙上')])
老大已经15岁了
老二已经14岁了
老三已经2岁了
老四已经在墙上了了

 

2.heapq 库是Python标准库之一，提供了构建小顶堆的方法和一些对小顶堆的基本操作方法(如入堆，出堆等)，可以用于实现堆排序算法

堆是一种基本的数据结构，堆的结构是一棵完全二叉树，并且满足堆积的性质：每个节点(叶节点除外)的值都大于等于(或都小于等于)它的子节点。

堆结构分为大顶堆和小顶堆，在heapq中使用的是小顶堆：

大顶堆：每个节点(叶节点除外)的值都大于等于其子节点的值，根节点的值是所有节点中最大的。

小顶堆：每个节点(叶节点除外)的值都小于等于其子节点的值，根节点的值是所有节点中最小的。

2.1使用heapq创建堆

heapq中创建堆的方法有两种。

heappush(heap, num)，先创建一个空堆，然后将数据一个一个地添加到堆中。每添加一个数据后，heap都满足小顶堆的特性(自动建立了小顶堆)。

heapify(array)，直接将数据列表调整成一个小顶堆。

# coding=utf-8
import heapq
 
 
heap = []
for num in array:
    heapq.heappush(heap, num)
print("array:", array)
print("heap: ", heap)

array = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
heapq.heapify(array)
print("array:", array)

# 运行结果
array: [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
heap:  [5, 7, 21, 15, 10, 24, 27, 45, 17, 30, 36, 50]
array: [5, 7, 21, 10, 17, 24, 27, 45, 15, 30, 36, 50]

2.2heappop() 

heapq.heappop()是从堆中弹出并返回最小的值