代码随想录训练营day13|LeetCode栈与队列part3

@代码随想录@程序员Carl

题目及讲解链接：第五章 栈与队列part03 (qq.com)

目录

239.滑动窗口最大值 

347.前K个高频元素 

 基础知识

1.下面这段代码是自定义了一个比较器。

2.下面这段代码是小顶堆的定义。

 3.这段代码遍历了一个 unordered_map 类型的映射 map。,>

 总结

239.滑动窗口最大值 

力扣题目链接：239. 滑动窗口最大值 - 力扣（LeetCode）

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

二刷，虽然还是没写出来，但是比第一遍清白点了

视频讲解中写push函数时用的是if，错了，应该用while。

时间复杂度O(n):易错！观察单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)。

空间复杂度O(k):因为我们定义了一个辅助队列que。

代码见下： 

class Solution {
public:
    class Myque{
    public:
        //用deque来实现单调队列
        deque<int> que;
        void pop(int val){
            //先判断que是否为空
            if(!que.empty() && que.front()==val){
                //pop_fornt不是pop_back!
                que.pop_front();   
            }
        }
        // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
        // 这样就保持了队列里的数值是单调从大到小的了。
        void push(int val){
            while(!que.empty() && val>que.back()){
                que.pop_back();
            }
            que.push_back(val);
        }
        // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
        int front(){
            return que.front();
        }
    };//忘记加分号了
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        Myque que;
        vector<int> result;
        // 先将前k的元素放进队列
        for(int i = 0;i<k;i++){
            que.push(nums[i]);
        }
        // 记录前k的元素的最大值
        result.push_back(que.front());
        for(int i = k;i<nums.size();i++){
            que.push(nums[i]);  // 滑动窗口前加入最后面的元素
            que.pop(nums[i-k]); // 滑动窗口移除最前面元素
            result.push_back(que.front());  // 记录对应的最大值
        }
        return result;
    }
};

347.前K个高频元素 

 力扣题目链接：347. 前 K 个高频元素 - 力扣（LeetCode）
 视频讲解链接：LeetCode：347.前 K 个高频元素_哔哩哔哩_bilibili

有点懵，我把自己一开始不了解的基础知识放在代码后了：

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.下面这段代码是自定义了一个比较器。

class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };

mycomparison 类是一个自定义的比较器，用于改变优先级队列（小顶堆）的行为。在这个类中，operator() 被重载以比较两个 pair<int, int> 类型的元素。比较器的逻辑是：如果左侧元素的第二个成员（频率）大于右侧元素的第二个成员，则返回 true。这导致小顶堆将频率较低的元素保持在堆顶。

这与优先级队列的底层实现有关，我想自个儿记着就行Õ_Õ

2.下面这段代码是小顶堆的定义。

priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

(1)std::priority_queue，这是 C++ 标准模板库（STL）中的一种容器适配器，通常用作大顶堆（最大堆）。但在这里，通过自定义比较函数mycomparison，它被配置为小顶堆（最小堆）。

(2)pair<int, int>：这是优先级队列存储的元素类型，每个元素都是一个 pair，其中包含两个 int 类型的值。

(3)vector<pair<int, int>>：这是用于内部存储的容器类型。std::priority_queue 默认使用 std::vector 作为其底层容器来存储元素。

(4)mycomparison：这是自定义的比较类，用于决定优先级队列中元素的顺序。在默认情况下，std::priority_queue 会将最大元素放在顶部。但由于这里使用了自定义比较器 mycomparison，队列现在是一个小顶堆，即最小元素在顶部。

 3.这段代码遍历了一个 unordered_map<int, int> 类型的映射 map。

for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
    pri_que.push(*it);

    ……

(1)unordered_map<int, int>::iterator it = map.begin();：这里创建了一个迭代器 it，用于遍历映射。迭代器 it 被初始化为指向映射的第一个元素。

(2)it != map.end();：这是循环的条件，当迭代器 it 没有到达映射的末尾时，循环继续。

(3)pri_que.push(*it);：在每次迭代中，迭代器指向的当前元素（由 *it 获取）被推入之前定义的优先级队列 pri_que 中。由于 it 是一个指向 pair<int, int> 的迭代器，*it 就是一个 pair<int, int> 类型的值。

 总结

我们用栈实现队列，用队列实现栈来掌握的栈与队列的基本操作。

接着，通过括号匹配问题、字符串去重问题、逆波兰表达式问题来系统讲解了栈在系统中的应用，以及使用技巧。

通过求滑动窗口最大值，以及前K个高频元素介绍了两种队列：单调队列和优先级队列，这是特殊场景解决问题的利器，是一定要掌握的。