代码随想录算法训练营第13天 | LeetCode239. 滑动窗口最大值 347.前 K 个高频元素 【单调队列，优先队列】

239. 滑动窗口最大值

看到这题题目，我最先想到的是暴力解法，遍历数组，然后在k的元素内找最大值，但是很明显，这样会超时，因此我们只能另寻他法。

看到这个滑动窗口的实现功能就像是一个队列——元素先进后出，对于这道题目，我们考虑使用单调队列来解决问题

什么是单调队列？

单调队列（Monotonic Queue）是一种特殊的队列数据结构，它具有以下特点：

1. 维护元素的单调性：单调队列中的元素按照一定的单调性进行排列，可以是递增或递减。一般情况下，我们使用递增排列。

2. 支持基本操作：单调队列支持队尾插入元素、队头删除元素和获取当前队列中的最值等基本操作。

基本操作包括以下几个步骤：

1. 队尾插入元素：当要插入一个元素时，我们需要从队尾开始，将所有比要插入的元素小的元素都从队尾删除，然后将新元素插入到队尾。这样可以保持队列的单调性。

2. 队头删除元素：当要删除队头元素时，我们只需要判断队头元素是否等于当前要删除的元素，如果是，则将队头元素删除。这样可以保证队列中的最值不会被删除。

3. 获取当前队列中的最值：当需要获取当前队列中的最值时，我们直接返回队头元素即可。

这些基本操作可以帮助我们解决一些需要维护窗口大小、求滑动窗口最大/最小值等问题。

那么这题题目，就是典型的使用单调队列解决的问题 

这道题目的具体解法也是如我介绍单调队列一样的解法，在滑动窗口中进行各种操作：

保持单调队列里的元素单调递减，那么队列出口的元素就是窗口里的最大元素；

我们该使用什么数据结构来实现目标呢？我认为使用deque最为合适，因为deque是一个双向队列，是queue的底层实现

下面来介绍些关于deque的基本操作

deque（双端队列）支持在队列的两端进行插入和删除操作。下面是关于deque的一些基本操作：

1. 插入元素：
   使用 deque.push_front() 函数将元素插入到deque的前端。
   使用 deque.push_back() 函数将元素插入到deque的后端。

2. 删除元素：
   使用 deque.pop_front(）函数从deque的前端删除一个元素。
   使用 deque.pop_back() 函数从deque的后端删除一个元素。

3. 访问元素：
    使用deque.front()函数获取deque的第一个元素。
    使用deque.back()函数获取deque的最后一个元素。

4. 长度：
   使用deque.size()函数获取deque中元素的个数。

具体思路如下：

创建一个类，在这个类中定义我们的单调队列，以及他执行的规则：

1.pop（）函数：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作

2.push()函数：push函数中包含了一些关于pop的操作，在当要push进去的元素大于队尾元素时，我们直接把队尾元素弹出，循环往复，直到push进来的元素小于队列的入口（队尾）元素的数值为止

3.front（）函数：只要保持以上规则，那么我们每次返回front，即队头元素就是当前滑动窗口的最大值

具体代码如下：

class Solution {
private:
class Mydeque{
public:
    deque<int>que;
    void pop(int val){
        if(!que.empty()&&que.front()==val){
            que.pop_front();
        }//保证非空的情况下，如果窗口滑动时，队头元素等于滑动窗口左边遍历到值时，弹出元素
    }

    void push(int val){
        while(!que.empty()&&que.back()<val){
            que.pop_back();//循环弹出小队尾比加入元素小的元素，保证队列里的元素时单调的
        }
        que.push_back(val);
    }

    int front(){
        return que.front();
    }
};
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int>result;
        Mydeque myque;
        for(int i=0;i<k;i++){
            myque.push(nums[i]);
        }
        result.push_back(myque.front());
        for(int i=k;i<nums.size();i++){
            myque.pop(nums[i-k]);
            myque.push(nums[i]); 
            result.push_back(myque.front());
        }
        return result;
    }
};

347. 前 K 个高频元素

对于这道题目，我最先想到是暴力法求解，但是题目要求时间复杂度必须由于O(n logn）

很显然，暴力法行不通，那么有什么办法能解这题题目呢？

回看题目，我们将其分解之后可以看出题目给我们提了三个要求：

1.求某个元素出现的频率

2.对元素出现的频率进行排序

3.找出高频的前K个元素

那么我们可以立马想使用unordered_map这中数据结构来解决于要求1，对于要求2和3，对频率进行排序，这里我们可以使用一种 容器适配器就是优先级队列。为什么不使用快排呢，使用快排还需要将map中的数存放到数组中，对整个数组进行排序，这里只需要对前k个进行排序就行了

什么是优先队列?

其实优先队列就是堆，用数组进行模拟的完全二叉树

作用：拿出优先级最大的元素

大顶堆（堆头是最大元素），小顶堆（堆头是最小元素）

定义：priority_queue<int>que;(默认大顶堆)表示值越大，越先出队

几种基本操作

que.size() 获得元素数量

que.push()

que.pop() 删除优先级最高的元素（堆顶元素，类似于对栈的操作）

que.top()  访问优先级最高的元素

que.empty() 查看堆是否为空

优先队列定义的进阶：

priority_queue<int, vector<int>,  greater<int> > pri_que; 

第一个参数代表其内部的元素类型，第二个参数代表其用什么容器存放元素，第三个参数可以是less<int>表示小于的意思，默认为大顶堆  或是   greater<int> 默认为小顶堆

对于自定义比较方法：

1.重写仿函数（函数对象）

#include<bits/stdc++.h>
#define ll long long
using namespace std;

#define PP pair<int,int>

struct cmp{    
            //重写仿函数
   bool operator()(PP a,PP b)
   {
       return a.first>b.first;
   }

};

int main()
{
     priority_queue<PP,vector<PP>,cmp> q;

     q.push(make_pair(4,6));
     q.push(make_pair(9,4));
     q.push(make_pair(6,1));
     while(!q.empty())
     {
         cout<<q.top().first<<q.top().second;
         q.pop();
     }

    return 0;
}

2.运算符重载：

#include<bits/stdc++.h>
#define ll long long
using namespace std;

#define PP pair<int,int>

struct Node{

    int x,y,z;
    Node(int a,int b,int c)
    {
        x=a,y=b,z=c;
    }
    bool operator<(const Node &a) const   //*****  运算符重载 < ,内置
    {
        return a.z>z;  //按z值降序
    }
};

int main()
{
    priority_queue<Node> q;
    q.push(Node(1,2,3));
    q.push(Node(3,9,1));
    q.push(Node(2,3,4));
    while(!q.empty())
    {
        cout<<q.top().x << endl<<q.top().y <<endl<<q.top().z;
        q.pop();
    }

    return 0;
}

 具体思路如下：

我们选择使用小顶堆，因为每次移动更新元素时，大顶堆都会弹出最大的元素，与我们的目的相悖，所以我们应该使用小顶堆，每次弹出最小的元素即可

具体代码如下：

class Solution {
public:
    class comparison{
        public:
        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) {
        vector<int>result;
        unordered_map<int,int>map;
        for(int i:nums){
            map[i]++;
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>,comparison>pri_que;
        for(auto it=map.begin();it!=map.end();it++){
            pri_que.push(*it);
            if(pri_que.size()>k){
                pri_que.pop();
            }
        }
        for(int i=0;i<k;i++){
            result.push_back(pri_que.top().first);
            pri_que.pop();
        }
        return result;
    }
};