代码随想录算法训练营第十三天|LeetCode239、LeetCode347

最新推荐文章于 2024-08-21 11:22:17 发布

钅黑

最新推荐文章于 2024-08-21 11:22:17 发布

阅读量58

点赞数

分类专栏：代码随想录刷题文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/starX5519/article/details/131696140

版权

代码随想录刷题专栏收录该内容

19 篇文章 0 订阅

订阅专栏

文章介绍了如何使用单调队列解决LeetCode239题，以及用优先队列解决LeetCode347题。在239题中，通过优化超时代码，利用单调队列实现滑动窗口的最大值。在347题中，使用优先队列找到数组中出现频率最高的k个元素。这两种数据结构在算法问题中起到了关键作用。

摘要由CSDN通过智能技术生成

LeetCode239

题目：

自己写的超时代码（思路应该没错）

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        queue<int> hua;
        int max = nums[0];
        int maxpos = 0;
        vector<int> plus;
        for(int i = 0;i < k;i++)
        {
            hua.push(nums[i]);
            if(nums[i] > max)
            {
                max = nums[i];
                maxpos = i;
            }
        }
        plus.push_back(max);
        for(int j = k;j <nums.size();j++)
        {
            hua.push(nums[j]);
            hua.pop();
            if(j-k+1 <= maxpos && nums[j]<max)
            {
                plus.push_back(max);
                continue;
            }
            else if(j-k+1 > maxpos)
            {
                max = nums[j-k+1];
                maxpos = j-k+1;
            for(int l = j-k+1;l <= j;l++)
            {
            if(nums[l] >= max)
            {
                max = nums[l];
                maxpos = l;
            }
            } 
            }
            else if(nums[j] >= max)
            {
                max = nums[j];
                maxpos = j;     
            }
            plus.push_back(max);    
        }
        return plus; 
    }
};

Carl：利用单调队列

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 value)
        {
            while(!que.empty() && value > que.back())
            {
                que.pop_back();
            }
            que.push_back(value);
        }
        int front()
        {
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
      MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) { // 先将前k的元素放进队列
            que.push(nums[i]);
        }
        result.push_back(que.front()); // result 记录前k的元素的最大值
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]); // 滑动窗口移除最前面元素
            que.push(nums[i]); // 滑动窗口前加入最后面的元素
            result.push_back(que.front()); // 记录对应的最大值
        }
        return result;   
        
    }
};

LeetCode347

题目：

Carl解法：（需要使用优先队列）

class Solution {
public:

    class mycomparison{
        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) {
        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>>,mycomparison> pri_que;

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

        vector<int> result(k);
        for(int i = 0;i < k;i++)
        {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
    return result;
    }
};

感悟：注意学会单调队列和优先队列的使用