算法训练Day13|栈与队列part03(LeetCode239. 滑动窗口最大值、LeetCode347. 前K个高频元素)

---

239. 滑动窗口最大值

题目链接
给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。

输入：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

提示：

• 1 <= nums.length <= 10^5
• 10^4 <= nums[i] <= 10^4
• 1 <= k <= nums.length

暴力解法

1.思路分析

暴力方法的思路不难想，遍历一遍的过程中每次从窗口中再找到最大的数值，放入提前定义好的vector数组中，最后 return vector。

2.代码实现

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> vec;
        for(int i=0;i<nums.size()&&i+k-1<nums.size();i++){
            int max=INT_MIN;
            for(int j=i;j<i+k;j++){
                if (nums[j]>max) max=nums[j];
            }
            vec.push_back(max);
        }
        return vec;
    }
};

3.复杂度分析

• 时间复杂度：
  两层for循环，一层遍历，一层找最大值，复杂度O(n × k)。

• 空间复杂度：
  定义了一个vector，用来接收窗口的最大值，复杂度O(n)。

在leetcode上是超时的，暴力解法不行，看这道题的难度也知道没这么简单了哈哈哈。

使用单调队列

进阶：
能在线性时间复杂度内解决此题吗？

1.思路分析

暴力解法时间复杂度O(n × k)，要想降低时间复杂度，去掉n是不太可能了，所有的数都要遍历一遍，但是如果能简化找窗口最大值的过程，说不定能把k去掉。
滑动窗口的移动过程像一个队列，然后随着窗口的移动，push进一个元素，pop出一个元素，如果再有一个找最大值的功能就好了。

可以用大顶堆吗？

用大顶堆就可以知道最大值是多少了， 但是问题是在弹出元素时，
如[1,3,-1,-3,5,3,6,7]，进入[1,3,-1]，队列维护的是[3,1,-1]，大顶堆只能弹出最大值，所以不能用大顶堆。

单调队列

单调队列维护里面的元素单调递增或者单调递减。每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值。
可惜没有这样的队列， 我们需要自己实现这么个队列。

单调队列怎么既能找到最大值又能移除元素？

其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。
但单调队列不是对窗口里面的数进行排序，如果排序的话，那和优先级队列没有区别了。

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

• pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作。
• push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止。

举例说明 [ 1,3,-1,0,5,3,4,7] ；k=3

• 先将前k的元素放进队列
  push(1):queue =[1]
  push(3):queue =[3]（3>1，pop(1)）
  push(-1):queue=[3,-1]（-1 result = [3]
• 滑动窗口挪动
  pop(1)：queue=[3,-1]（1！=front，跳过）
  push(0):queue=[3,0]（0>back，pop(-1)再push(0)）
  result = [3,3]
• 滑动窗口挪动
  pop(3)：queue=[0]（3==front，pop(3)）
  push(5):queue=[5]（5>back，pop(3)再push(5)）
  result = [3,3,5]
• 滑动窗口挪动
  pop(-1)：queue=[5]（-1！=front，跳过）
  push(3):queue=[5,3]（3 result = [3,3,5,5]
• 滑动窗口挪动
  pop(0)：queue=[5,3]（0！=front，跳过）
  push(4):queue=[5,4]（4>back，pop(3)再push(4)）
  result = [3,3,5,5,5]
• 滑动窗口挪动
  pop(5)：queue=[5,4]（5==front，pop(5)）
  push(7):queue=[7]（7>back，pop(5)pop(4)再push(7)）
  result = [3,3,5,5,5,7]

2.代码实现

class Solution {
public:
    class myqueue{
    public:
        // 使用deque来实现单调队列
        deque<int> que;
        void push(int index){
            while(!que.empty()&&index>que.back()){
                que.pop_back();
            }
            que.push_back(index);
        }
        void pop(int index){
            if(index==que.front()) que.pop_front();
        }
        int get_max(){
            return que.front();
        }    
    };
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        myqueue que;
        vector<int> result;
        for(int i=0;i<k;i++){
            que.push(nums[i]);   
        }
        result.push_back(que.get_max());
        for(int i=0;i+k<nums.size();i++){
            que.pop(nums[i]);
            que.push(nums[i+k]);
            result.push_back(que.get_max());  
        }
        return result;
    }
};

记录两个错误点：
在myqueue类里定义了一个queue，结果不能实现pop_back、pop_front这些函数。
是因为 queue 是一个适配器容器，它默认基于 deque 实现，但是它没有 pop_back 成员函数。pop_back 是 deque 的成员函数，用于在容器尾部移除一个元素。
push函数当时写成了

 void push(int index){
            if(!que.empty()&&index>que.front()){
                while(!que.empty()){
                    que.pop_back();
                }
                que.push_back(index);
            }
            else que.push_back(index);
        }

要实现的是单调队列，在插入元素时应该把队列里比元素小的去掉。

3.复杂度分析

• 时间复杂度：O(N)
  nums 中的每个元素最多也就被 push_back，和front比较 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度是 O(n)；

• 空间复杂度：O(K）
  定义一个辅助队列，所以是O(k)。

4.总结思考

题解中单调队列里的pop和push接口，仅适用于本题。单调队列不是一成不变的，而是不同场景不同写法。总之要保证队列里单调递减或递增的原则，所以叫做单调队列。
C++中deque是stack和queue默认的底层实现容器（这个我们之前已经讲过啦），deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。

本题学习时间⌛️：3h

---

347. 前K个高频元素

题目链接
给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

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

示例 2:
输入: nums = [1], k = 1
输出: [1]
提示：

你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 $O(n\log n)$ , n 是数组的大小。
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。

1.思路分析

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

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

如何求每个每个数据出现的频率

这一类的问题在有效的字母异位词里遇到过，可以使用map来进行统计。

如何对频率进行排序

可以使用一种 容器适配器就是优先级队列。

什么是优先级队列呢？

其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

而且优先级队列内部元素是自动依照元素的权值排列。
缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。

什么是堆呢？

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。
所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。

本题我们就要使用优先级队列来对部分频率进行排序。

是使用小顶堆呢，还是大顶堆？

有的同学一想，题目要求前 K 个高频元素，那么果断用大顶堆啊。
那么问题来了，定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢。

所以我们要用小顶堆，只维护k个数据，每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

这样遍历一遍元素时间复杂度是n，往堆里插入一个元素时间复杂度是logk。

找出前K个高频元素

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

为什么不用快排呢

使用快排要将map转换为vector的结构，然后对整个数组进行排序，时间复杂度O(nlogn) 。而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。

2.代码实现

要对键值对排序，需要自己实现一个小顶堆的实现方法compare()，
遍历map，一个一个加入队列，如果队列元素个数大于k，就pop()。
定义一个result数组，倒序遍历result，把队列元素赋值给result，相当于实现了倒序，频率由高到低。

class Solution {
public:
    class compare{
    public:
        //重写仿函数
        bool operator()(const pair<int,int> &l,const pair<int,int> &r){
            return l.second>r.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int> map;
        for(int i=0;i<nums.size();i++){
            map[nums[i]]++;
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>,compare> que;
        unordered_map<int,int>::iterator it;
        for(it=map.begin();it!=map.end();it++){
            que.push(*it);
            if(que.size()>k) que.pop();
        }
        vector<int> result(k);
        k--;
        while(!que.empty()){
            result[k--]=(que.top().first);
            que.pop();
        }
        return result;

    }
};

3.复杂度分析

• 时间复杂度: O(nlogk)

遍历一遍元素，创建unordered_map的时间复杂度是O(n)。
遍历map里面的pair，因为小顶堆的底层实现就是二叉树，插入每个元素到二叉数是O(logK），插入所有元素是O(NlogK)。
创建结果列表 vector result(k) 需要 O(k) 的时间复杂度。
将优先队列中的元素依次弹出并放入结果列表中，弹出每个元素的时间复杂度为 O(log K)，总共需要 O(Klog K) 的时间复杂度。
整个过程的复杂度为O(NlogK)。

• 空间复杂度: O(n)

建立map是O(n)，还要一个大小为O(K)的队列。

4.总结思考

大家对这个比较运算在建堆时是如何应用的，为什么左大于右就会建立小顶堆，反而建立大顶堆比较困惑。

确实 例如我们在写快排的cmp函数的时候，return left>right 就是从大到小，return left

优先级队列的定义正好反过来了，默认的大顶堆比较函数是less，less是left 这道题是堆的一道很经典的题目，对于我来说要掌握堆的代码实现语法。

本题学习时间⌛️：2h

---