代码随想录|day 12

最新推荐文章于 2024-07-18 23:31:00 发布

东鹅鹅鹅

最新推荐文章于 2024-07-18 23:31:00 发布

阅读量1k

点赞数 38

文章标签：开发语言 c++

本文链接：https://blog.csdn.net/donge520/article/details/136045316

版权

Day 12

notes：个人学习笔记，欢迎交流，引用学习过程均附上链接，不足欢迎指出。

一、理论学习

今日是视频日，两道题目都不简单，我们学习两个数据结构【单调队列】和【优先级队列】

补充记录【lambda 】: 所谓lambda是一份功能定义式，可被定义于语句(statement)或表达式(expression)内部。因此你可以拿lambda当作inline函数使用。C++sort如何使用lambda表达式对一维vector和二维vector进行排序_lambda vector-CSDN博客

1.【单调队列】：“如果一个选手比你小还比你强，你就可以退役了。”——单调队列的原理(算法学习笔记(66): 单调队列 - 知乎 (zhihu.com))

「单调」指的是元素的「规律」——递增（或递减）。

例如我们构造一个单调递增的队列会如下：

原序列为：（单调队列 - OI Wiki (oi-wiki.org)）

`1`	`1 3 -1 -3 5 3 6 7`

因为我们始终要维护队列保证其递增的特点，所以会有如下的事情发生：

操作	队列状态
1 入队	`{1}`
3 比 1 大，3 入队	`{1 3}`
-1 比队列中所有元素小，所以清空队列 -1 入队	`{-1}`
-3 比队列中所有元素小，所以清空队列 -3 入队	`{-3}`
5 比 -3 大，直接入队	`{-3 5}`
3 比 5 小，5 出队，3 入队	`{-3 3}`
-3 已经在窗体外，所以 -3 出队；6 比 3 大，6 入队	`{3 6}`
7 比 6 大，7 入队	`{3 6 7}`

「队列」指的是元素只能从队头和队尾进行操作。以下是我们自定义的操作

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

        }
        int front(){
            return que.front();
        }
    };

2.【优先级队列】

什么是优先级队列呢？

priority_queue<int,vector<int> , greater<>> pq;//这是对的

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

和队列基本操作相同:

top 访问队头元素
empty 队列是否为空
size 返回队列内元素个数
push 插入元素到队尾 (并排序)
emplace 原地构造一个元素并插入队列
pop 弹出队头元素
swap 交换内容

二、刷题部分

239. 滑动窗口最大值

该题视频链接：单调队列正式登场！| LeetCode：239. 滑动窗口最大值_哔哩哔哩_bilibili

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 val){
            while(!que.empty() && val>que.back()){
                que.pop_back();
            }
            que.push_back(val);

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

    }
};

347. 前 K 个高频元素

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

要统计元素出现频率
对频率排序C++ STL unordered_map按照value排序_unordered_map sort by key-CSDN博客我的解法
找出前K个高频元素

我的解法：nlogn

class Solution {
public:

    vector<int> topKFrequent(vector<int>& nums, int k) {
       unordered_map<int,int>maps;
       for(int i=0;i<nums.size();++i){
           maps[nums[i]]++;
       }
       vector<pair<int,int>>res(maps.begin(),maps.end());
       sort(res.begin(),res.end(),[](pair<int, int>& l, pair<int, int>& r){
           
           
            return  l.second > r.second;
       });
       vector<int>ans;
       for(int i=0;i<k;++i){
           ans.push_back(res[i].first);
       }
       return ans;




    }
};

卡哥解法：nlogk

347.前K个高频元素

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;

    }
};