day13| 239. 滑动窗口最大值，347.前 K 个高频元素，总结

小生舞梦蝶

已于 2023-02-13 15:12:08 修改

阅读量120

点赞数

分类专栏：刷题文章标签：算法 leetcode 数据结构

于 2023-02-13 15:09:40 首次发布

本文链接：https://blog.csdn.net/qq_40805815/article/details/129006813

版权

刷题专栏收录该内容

32 篇文章 0 订阅

订阅专栏

一、239. 滑动窗口最大值

力扣题目链接

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

返回滑动窗口中的最大值。

进阶：

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

未看题解时我的解答，暴力解法，部分正确。
我的思路错了，我以为是通过滑动窗口求整个数组最大值，其实是只求滑动窗口最大值。那我确实不会，因为滑动窗口往后走的时候还有可能去掉之前的最大值。
哦，暴力还是可以解出来的，每次都要for一遍滑动窗口最大值。

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

在这里插入图片描述

看了代码随想录题解视频，没想到这是一个使用单调队列这种高级数据结构的题目，单调队列使用双向队列实现（deque），本题要找最大值，所以使用非递增队列。
本题目无法使用大小顶堆进行解答，因为排序后无法得知需要pop掉的元素是哪一个。
看了一遍视频思路能看懂，就是维护这个单调队列，主要实现三个逻辑，单调队列的pop()，push()，getMaxValue()。所以这道题除了三个逻辑要实现之外，还要写调用这三个逻辑的主函数。
代码照着代码随想录抄了一遍，倒是感觉不复杂，只要记得维护的是这样一个单调队列就可以了，仅仅只是代码量有点多。
值得一提的是，题解的主代码部分的结构和我自己写的结构有相似的地方，都是先弄好最前面k部分的数，然后随着i增加，每次输出一个最大值。

class Solution {
private:
    class MyQueue{
        public:
        deque<int> que;
        void pop(int value){
            if(!que.empty() && value == que.front()){
                que.pop_front();
            }
        }
        void push(int value){
            while(!que.empty() && value > que.back()){
                que.pop_back();
            }
            que.push_back(value);
        }
        int front(){
            return que.front();
        }
    };

public:
    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.front());
        for(int i=k; i<nums.size(); i++){
            que.pop(nums[i-k]);
            que.push(nums[i]);
            result.push_back(que.front());
        }
        return result;
    }
};

二、347.前 K 个高频元素

力扣题目链接

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

示例 1:

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

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

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

看到这道题目我的想法是：
1.先排序，排序用sort就行，排序至少保证相同的元素都在一起。
2.然后维护大小为k的pair或者是map，有键值对或者一对就可以。
3.可能map好一些，因为map可以选有序的，容易维护一些。
不过写代码之前还是先看一下题解吧。

优先级队列正式登场！大顶堆、小顶堆该怎么用？| LeetCode：347.前 K 个高频元素

使用优先级队列（底层实现就是大/小顶堆），头节点是最大的叫大顶堆。头节点最小的叫小顶堆。由于快排时间复杂度为 $\log n)$ ，为了减小时间复杂度，这里不需要维护n个元素，只需要维护k个元素，所以时间复杂度可以降为 $\log k)$ ，在n较大且k较小的情况下性能提升较为明显。
由于只需要维护k个元素，在新元素push的情况下，被弹出的是堆顶的元素，所以反而要选择小顶堆，每次都让最小的元素被弹出去，才能使得最后剩下来的是前k个频率最高的元素。
可以看出我一开始的思路和题解思路有很大的相似性，只是因为一开始我不知道有大/小顶堆的这个东西存在，所以我需要自己先排序，并且没有想清楚具体怎么维护。而我和题解一样都选择使用map。但这也说明了之前的刷题是很有用的，至少遇到新题能用已学过的方法去思考，上面我思考的就是哈希法。
要记得 map[key]++ 这种写法，表示括号里面的是key，而value从零开始做++，可以按照这种方式省略不写。
思路看懂了，照着题解敲了一边代码，这个题的代码看着挺陌生的。估计是operator，priority_queue，pair之类的用法之前没接触过。

/ 时间复杂度：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<nums[i],对应出现的次数>
        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;

    }
};

三、总结

1.栈和队列作为基础的相互实现。（这两个当天有事就跳过了）
2.普通栈能解决的三个经典问题：有效的括号，删除字符串中所有的相邻重复项，逆波兰表达式。
3.队列的应用：单调队列（高级数据结构）解决滑动窗口最大值，优先队列（底层是大/小顶堆）解决前k个高频元素。单调队列可以用一般队列自己实现逻辑，优先队列可以用标准库的priority_queue直接定义大小顶堆。