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

239. 滑动窗口最大值

Problem: 239. 滑动窗口最大值

1.思路

C++标准库（STL）中没有直接提供名为“单调队列”（Monotonic Queue）的数据结构。单调队列是一种特殊的队列，它在添加新元素的同时保持队列中元素的单调递增或递减顺序。这种数据结构常用于解决滑动窗口类问题，比如求滑动窗口的最大值或最小值。

虽然C++ STL中没有直接提供单调队列，但是我们可以使用std::deque（双端队列）来实现单调队列的功能。std::deque允许我们在队列的两端进行插入和删除操作，这正是实现单调队列所需要的。

实现单调递增队列的示例：

以下是使用std::deque实现单调递增队列的一个简单示例。这个单调队列在添加新元素时，会从队尾开始移除所有小于新元素的值，以保持队列的单调递增性。

#include <iostream>
#include <deque>
#include <vector>

class MonotonicQueue {
public:
    // 向队列中添加元素，并保持单调递增
    void push(int value) {
        while (!data.empty() && data.back() < value) {
            data.pop_back();
        }
        data.push_back(value);
    }

    // 返回队首元素
    int front() {
        return data.front();
    }

    // 如果队首元素是旧的最大值，则移除它
    void pop(int value) {
        if (!data.empty() && data.front() == value) {
            data.pop_front();
        }
    }

private:
    std::deque<int> data;
};

int main() {
    MonotonicQueue mq;
    std::vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3; // 窗口大小

    for (int i = 0; i < nums.size(); ++i) {
        if (i < k - 1) {
            mq.push(nums[i]);
        } else {
            mq.push(nums[i]);
            std::cout << mq.front() << " ";
            mq.pop(nums[i - k + 1]);
        }
    }

    return 0;
}

这个示例展示了如何使用单调队列来处理一个简单的滑动窗口问题。注意，这里的pop方法假设要移除的元素确实是队列中的当前最大值，因此在使用时需要确保这一点。

通过这种方式，虽然C++ STL没有直接提供单调队列，但我们可以灵活地使用现有的数据结构来实现所需的功能。

2.Code

写在函数里面

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //需要用单调队列来做，因为这个需要判断在移除了一个元素和新增了一个元素之后，这个新增的元素在现在当前窗口中的位置
        //c++中没有定义单调队列，可以使用双端队列deque来实现，当插入元素时，移除队列尾部小于插入值的元素，以此保证队列的单调性
        deque<int> dq;
        vector<int> maxnum;
        //初始化滑动窗口
        int i = 0;
        while(i < k){
            //删除队列中比nums[i]小的值,从尾端删除，因为插入的时候是有序的，所以不需要担心删除的时候队列是无序的
            while(!dq.empty() && dq.back() < nums[i]){
                dq.pop_back();
            }
            dq.push_back(nums[i]);
            i++;
        }
        maxnum.push_back(dq.front());
        
        while(i < nums.size()){//窗口滑动开始
            //先将新元素加入(删除小于新元素的值，将新元素加入队列)
            while(!dq.empty() && dq.back() < nums[i]){
                dq.pop_back();
            }
            dq.push_back(nums[i]);
            //如果被移走的是队列中的最大值,则移除队列中的最大值
            if(nums[i-k]==dq.front()) dq.pop_front();
            maxnum.push_back(dq.front());
            i++;
        }
        return maxnum;

    }
};

347. 前 K 个高频元素

Problem: 347. 前 K 个高频元素

1.解题方法

使用优先队列来维护最小堆，之前学的堆是用完全二叉树来做的。堆排序里面回用到完全二叉树的写法。这里只是维护一个最小堆，只需要记录结果，可以直接用优先队列来做。

我认为的难点在与map的比较很难，最后的写法是自己定义了一个比较器，注意map中的每一个元素的结构其实都是一个pair，如果在比较器里面写map，这个比较器就会比较不同map之间，而不是同一个map的pair。

比较器中，如果是按大排序，则填<
如果是按小排序，则填>
只要注意，是反着来的就行了

如果优先队列中的元素是int，是不需要写比较器的，默认的排序是大顶堆，如果像实现小顶堆，可以这样定义priority_queue<int, vector<int>, greater<int>> minHeap; // greater<int> 创建最小堆

2.Code

class Solution {
public:
    //自定义比较器，用于比较unordered_map中的两个pair
    struct CompareMaps{
        bool operator()(const pair<int,int>& a, const pair<int,int>& b){
            return a.second > b.second;
        }
    };
    
    vector<int> topKFrequent(vector<int>& nums, int k) {
        //记录频率
        unordered_map<int,int> mp;
        for(auto num: nums){
            mp[num]++;
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>, CompareMaps> pri_q;
        for(auto it = mp.begin(); it != mp.end(); it++){
            pri_q.push(*it);
            if(pri_q.size() > k){
                pri_q.pop();
            }
        }
        vector<int> res(k);
        for(int i = k - 1; i >= 0; i--){
            res[i] = pri_q.top().first;
            pri_q.pop();
        }
        return res;
    }
};