代码随想录第刷题12天

代码随想录第刷题12天

滑动窗口最大值

暴力解法：会超时

/*
 * @lc app=leetcode.cn id=239 lang=cpp
 *
 * [239] 滑动窗口最大值
 */

// @lc code=start
#include <string>
#include <stack>
#include <vector>
using namespace std;

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
      vector<int> result;
      for (int i = 0; i < nums.size()-k+1; i++)
      {
        int path = nums[i];
        for (int j = i+1; j < k+i; j++)
        {
           path =  path > nums[j] ? path : nums[j];
        }
        result.push_back(path);
      }
        return result;
    }
};
// @lc code=end

队列的解法:

自己写一个单调队列，注意维护队列的单调性

/*
 * @lc app=leetcode.cn id=239 lang=cpp
 *
 * [239] 滑动窗口最大值
 */

// @lc code=start
#include <string>
#include <stack>
#include <vector>
#include <deque>
using namespace std;

class Solution {
public:

    class MyQueue
    {
    private:
        
    public:
        deque<int> que;

    void pop(int value){
        if (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();
    }
    };
    




    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++)
        {
            que.push(nums[i]);
        }
        result.push_back(que.front());

        for (int i = k; i < nums.size(); i++)
        {
           que.pop(nums[i-k]);
            que.push(nums[i]);
            result.push_back(que.front());
        }
        
        return result;
    }
};
// @lc code=end

前 K 个高频元素

需要掌握优先级队列，也就是大小顶堆的构造，链接如下：

优先级队列学习

B站讲解

/*
 * @lc app=leetcode.cn id=347 lang=cpp
 *
 * [347] 前 K 个高频元素
 */

// @lc code=start
#include <string>
#include <stack>
#include <vector>
#include <deque>
#include <unordered_map>
#include   <queue>
using namespace std;

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;
        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);
        //no need sort
        for (int i = 0; i < k; i++)
        {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
     
         return result;
    }
};
// @lc code=end

核心思路如下：

1. 首先利用哈希表map映射，计算每个元素出现的次数
2. 构造优先级队列，使用小顶堆，要大的所以弹出小的
3. 利用小顶堆进行排序，大于要求的k个之后就弹出
4. 新建一个结果数组，讲堆顶元素插入，插入k个即可。要求顺序的话就从后面往前插入