代码随想录算法训练营Day13 | 栈与队列part03

原创已于 2024-01-10 21:37:21 修改 · 556 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #leetcode

于 2024-01-10 21:32:20 首次发布

本文介绍了如何使用单调队列和优先级队列解决LeetCode中的两个问题：滑动窗口最大值和前K个高频元素。作者分享了实现这两个问题的C++代码，以及遇到的思路不清和编程挑战。

239. 滑动窗口最大值

leetcode链接
 代码随想录链接
一刷状态：未通过（思路不清晰）

思路

定义好一个单调队列（单调递减）
pop：如果pop的数值是队列的最大值，即队列的front，则将front的值pop，若不是，则不变化。
push：因为需要保证单调递减，所以需要从后往前比对数值，如果push的值大于back的值，则将back的值pop。
难点在于单调队列的构建，把滑动窗口的滑动理解为push窗口末端元素，pop窗口的前一个元素，利用单调队列的特性，找到每一个窗口的最大值，即front的值。

class Solution {
private:
    class MyQueue{
    public:
        deque<int> dq;

        void pop(int value)
        {
            if(dq.empty()==0 && dq.front()==value)
            {
                dq.pop_front();
            }
        }

        void push(int value)
        {
            while(dq.empty()==0 && dq.back()<value)
            {
                dq.pop_back();
            }
            dq.push_back(value);
        }

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

public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> result;
        int n = nums.size();
        if(n==0) return result;

        MyQueue queue;

        for(int i=0; i<k; i++)
        {
            queue.push(nums[i]);
        }

        result.push_back(queue.front());

        for(int i = k; i<n; i++)
        {
            queue.pop(nums[i-k]);
            queue.push(nums[i]);
            result.push_back(queue.front());
        }

        return result;
    }
};

347.前 K 个高频元素

leetcode链接
 代码随想录链接
一刷状态：未通过（思路不清晰）

思路

使用优先级队列的特性，排列pair<nums[i], 数量>，使用小顶堆，这样子才能pop出最小的pair，然后遍历整个map，挤掉最小的pair，得到最大的topK。
难点在于自定义优先级队列priority_queue 的排序函数，注意C++的语法。

class Solution {
public:
    struct cmp{
        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> map;

        for(int i=0; i<nums.size(); i++)
        {
            map[nums[i]]++;
        }

        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> priQue;

        for(auto m:map)
        {
            priQue.push(m);
            if(priQue.size()>k)
            {
                priQue.pop();
            }
        }

        vector<int> result(k);
        for(int i=k-1; i>=0; i--)
        {
            result[i] = priQue.top().first;
            priQue.pop();
        }

        return result;

    }
};