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

参考

代码随想录

题目一：LeetCode 239.滑动窗口最大值

这个题之前没有做过，如果直接用暴力求解的话必定超时，除此之外想不到其他求解方法。代码随想录里用的单调队列，看了题解还是很好理解的，记录一下自己的理解。
假设数组nums = [1,3,1,2,0,5]，k = 3，要维护一个单调队列，从front到back是单调递减的，窗口中的最大值总是在队列的front位置，每次往队列中放入数据都要和队列的back元素比较，以保证单调性（注意这里是和back位置的元素比较，而不是front位置）。单调队列用C++里的双端队列deque构建。

• 创建滑动窗口
  第一个数为1，此时单调队列为空，直接添加元素。第二个数为3，和单调队列的back元素1比较，由于3>1，所以弹出1，放入3。第三个数为1，和和单调队列的back元素3比较，由于3>1，所以直接将1放入队列中。至此，滑动窗口创建完成，滑动窗口中的最大值为3，如下图所示：
  
• 向右移动窗口，此时窗口中丢弃数值1，丢弃的数值1不是目前的最大值3，所以不用弹出；新添加的数值为2，由于2要比队列back位置处的1大，所以将1从back处弹出，2小于3，所以将2添加到队列中，此时滑动窗口的最大值为3，如下图所示：
  
• 继续向右移动窗口，此时丢弃的数值为3，正好是当前的最大值，所以要将3从队列中弹出；新添加的数值为0，比队列的back位置处的2要小，所以直接将0添加到队列中，此时的最大值为2，如下图所示：
  
• 继续向右移动窗口，此时丢弃的数值为1，不等于当前的最大值2，所以不用将最大值2弹出；新添加的元素为5，与队列back位置进行比较，由于5比0和2都大，所以将0和2都弹出，将5加入对立队列中，此时的最大值为5，如下图所示：
  
  这样就遍历完成了。从上面的过程可以看出，这个单调队列的数值从front到back始终是单调递减的，最大值始终在front位置处，每次移动窗口，要判断从窗口中移除的元素是否为最大值，若是则需要将最大值从队列中弹出，若不是则不需要；每次移动窗口，新添加的元素要与back位置处的元素进行比较，直到新添加的元素比back位置处的元素数值小。可以看出，用双端队列的原因是，从front位置弹出最大值，从back位置弹出比新元素小的元素，这样这个队列就能始终保持单调递减了。代码实现如下：

class Solution {
public:
    void pop(int val)   //  弹出滑动窗口最左边的值
    {
        if(val == que.front())
            que.pop_front();
    }
    void push(int val)  //往滑动窗口里添加新值
    {
        while(!que.empty() && que.back() < val)    que.pop_back();
        que.push_back(val);
    }
    int getMaxValue()   //获取滑动窗口中的最大值
    {
        return que.front();
    }
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> result;
        /* 创建滑动窗口 */
        for(int i=0;i<k;i++)  push(nums[i]);
        /* 获取最大值 */
        result.push_back(getMaxValue());
        /* 向右移动滑动窗口 */
        for(int i=k;i<nums.size();i++)
        {
            pop(nums[i-k]); // 移除滑动窗口最左边的值
            push(nums[i]);  //往滑动窗口里添加新值
            result.push_back(getMaxValue());  //获取滑动窗口里的最大值
        }
        return result;
    }
private:
    deque<int> que;
};

注意，代码中的pop和push是针对滑动窗口而言的，不要与队列的两个函数混淆。

二刷代码补充：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        deque<int> deq;
        vector<int> vec;
        //创建滑动窗口，初始化单调队列
        for(int i = 0; i < k - 1; i++){
            while(!deq.empty() && nums[i] > deq.back()) deq.pop_back();	//弹出比当前元素小的元素
            deq.push_back(nums[i]);
        }
        for(int i = k - 1; i < nums.size(); i++) {
            while(!deq.empty() && nums[i] > deq.back()) deq.pop_back(); //弹出比当前元素小的元素
            deq.push_back(nums[i]);		//添加当前元素
            vec.push_back(deq.front());	//添加记录当前窗口中的最大值
            if(deq.front() == nums[i - k + 1])	//如果最大值已经不在窗口中，则需要将最大值从单调队列中弹出
                deq.pop_front();
        }
        return vec;
    }
};

题目二：LeetCode 347.前 K 个高频元素

这个题看了题目之后的想法是哈希+快排，具体做法是用map来统计每个数值出现的次数，数值作为key，次数作为value，然后对value进行排序即可，这种解法的时间复杂度是O(nlong)。但这里是栈与队列的专题，所以应该有更好的解法。代码随想录里给出的做法是用优先级队列（小顶堆）来找到前k个高频元素而不需要对全部进行排列。

什么是优先级队列

在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。通常采用堆数据结构来实现。

什么是堆

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

C++里提供了优先级队列priority_queue，可以直接用它来实现堆。代码随想录给出的代码如下：

// 时间复杂度：O(nlogk)
// 空间复杂度：O(n)
class Solution {
public:
    // 小顶堆
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 要统计元素出现频率
        unordered_map<int, int> map; // map
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        // 对频率排序
        // 定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};

代码的实现思路很好理解，但是里面一些C++的东西不太明白，这里补充一下。

priority_queue

template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
    > class priority_queue;

• T - 存储的元素类型
• Container - 用于存储元素的底层容器类型
• Compare - 提供严格弱序的比较 (Compare) 类型。注意比较 (Compare) 形参的定义，使得若其第一参数在弱序中先于其第二参数则返回 true 。但因为 priority_queue 首先输出最大元素，故“先来”的元素实际上最后输出。即队列头含有按照比较 (Compare) 所施加弱序的“最后”元素。

pair

功能：pair将一对值(T1和T2)组合成一个值，这一对值可以具有不同的数据类型（T1和T2），两个值可以分别用pair的两个公有函数first和second访问。

pair<int,double> p(3,3.14);
cout << p.first << endl;
cout << p.second << endl;

operator

参考：https://zhuanlan.zhihu.com/p/353189480

c++ 中的operator()有两大主要作用：

• Overloading： 重载()操作符
• Casting ：实现对象类型转化

1）Overloading： 重载()操作符

class maxValue
{
public:
  int operator() (int& a,int& b)
  {
    return a > b ? a : b;
  }
};

int main()
{
    int a = 3,b = 4;
    maxValue getMax;
    cout << "max = " << getMax(a,b) << endl;  //输出4
    return 0;
}

题解中给出的用法就是这种。

2）Casting ：实现对象类型转化

class testClass
{
public:
    double val = 3.14;
    operator int()
    {
        return val;
    }
};

int main()
{
    testClass test;
    cout << test << endl;  //输出3
    return 0;
}

哈希+快排的实现：

class Solution {
public:
    static bool cmp(pair<int, int> a, pair<int, int> b)
    {
        return a.second > b.second;
    }
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> umap;
        vector<int> result;
        for(int i = 0; i < nums.size(); i++) 
            umap[nums[i]]++;
        vector<pair<int, int>> vec(umap.begin(), umap.end());
        sort(vec.begin(), vec.end(), cmp);
        for(int i = 0; i < k; i++)
            result.push_back(vec[i].first);
        return result;
    }
};

今日小结

今天的题有一定难度，但是看了题解还是很好理解的，一个题用的是单调队列，一个题用的优先级队列（小顶堆），思路不难理解，但第二题给出的代码里有些不明白的C++知识，不明白的点做了简单总结。