代码随想录算法训练营第13天 | LeetCode239. 滑动窗口最大值 347.前 K 个高频元素 【单调队列,优先队列】


239. 滑动窗口最大值

看到这题题目,我最先想到的是暴力解法,遍历数组,然后在k的元素内找最大值,但是很明显,这样会超时,因此我们只能另寻他法。

看到这个滑动窗口的实现功能就像是一个队列——元素先进后出,对于这道题目,我们考虑使用单调队列来解决问题

什么是单调队列?

单调队列(Monotonic Queue)是一种特殊的队列数据结构,它具有以下特点:

1. 维护元素的单调性:单调队列中的元素按照一定的单调性进行排列,可以是递增或递减。一般情况下,我们使用递增排列。

2. 支持基本操作:单调队列支持队尾插入元素、队头删除元素和获取当前队列中的最值等基本操作。

基本操作包括以下几个步骤:

1. 队尾插入元素:当要插入一个元素时,我们需要从队尾开始,将所有比要插入的元素小的元素都从队尾删除,然后将新元素插入到队尾。这样可以保持队列的单调性。

2. 队头删除元素:当要删除队头元素时,我们只需要判断队头元素是否等于当前要删除的元素,如果是,则将队头元素删除。这样可以保证队列中的最值不会被删除。

3. 获取当前队列中的最值:当需要获取当前队列中的最值时,我们直接返回队头元素即可。

这些基本操作可以帮助我们解决一些需要维护窗口大小、求滑动窗口最大/最小值等问题。

那么这题题目,就是典型的使用单调队列解决的问题 

这道题目的具体解法也是如我介绍单调队列一样的解法,在滑动窗口中进行各种操作:

保持单调队列里的元素单调递减,那么队列出口的元素就是窗口里的最大元素;

我们该使用什么数据结构来实现目标呢?我认为使用deque最为合适,因为deque是一个双向队列,是queue的底层实现

下面来介绍些关于deque的基本操作

deque(双端队列)支持在队列的两端进行插入和删除操作。下面是关于deque的一些基本操作:

1. 插入元素:
   使用 deque.push_front() 函数将元素插入到deque的前端。
   使用 deque.push_back() 函数将元素插入到deque的后端。

2. 删除元素:
   使用 deque.pop_front()函数从deque的前端删除一个元素。
   使用 deque.pop_back() 函数从deque的后端删除一个元素。

3. 访问元素:
    使用deque.front()函数获取deque的第一个元素。
    使用deque.back()函数获取deque的最后一个元素。

4. 长度:
   使用deque.size()函数获取deque中元素的个数。

具体思路如下:

创建一个类,在这个类中定义我们的单调队列,以及他执行的规则:

1.pop()函数:如果窗口移除的元素value等于单调队列的出口元素,那么队列弹出元素,否则不用任何操作

2.push()函数:push函数中包含了一些关于pop的操作,在当要push进去的元素大于队尾元素时,我们直接把队尾元素弹出,循环往复,直到push进来的元素小于队列的入口(队尾)元素的数值为止

3.front()函数:只要保持以上规则,那么我们每次返回front,即队头元素就是当前滑动窗口的最大值

具体代码如下:

class Solution {
private:
class Mydeque{
public:
    deque<int>que;
    void pop(int val){
        if(!que.empty()&&que.front()==val){
            que.pop_front();
        }//保证非空的情况下,如果窗口滑动时,队头元素等于滑动窗口左边遍历到值时,弹出元素
    }

    void push(int val){
        while(!que.empty()&&que.back()<val){
            que.pop_back();//循环弹出小队尾比加入元素小的元素,保证队列里的元素时单调的
        }
        que.push_back(val);
    }

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


347. 前 K 个高频元素

对于这道题目,我最先想到是暴力法求解,但是题目要求时间复杂度必须由于O(n logn)

很显然,暴力法行不通,那么有什么办法能解这题题目呢?

回看题目,我们将其分解之后可以看出题目给我们提了三个要求:

1.求某个元素出现的频率

2.对元素出现的频率进行排序

3.找出高频的前K个元素

那么我们可以立马想使用unordered_map这中数据结构来解决于要求1,对于要求2和3,对频率进行排序,这里我们可以使用一种 容器适配器就是优先级队列。为什么不使用快排呢,使用快排还需要将map中的数存放到数组中,对整个数组进行排序,这里只需要对前k个进行排序就行了

什么是优先队列?

其实优先队列就是,用数组进行模拟的完全二叉树

作用:拿出优先级最大的元素

大顶堆(堆头是最大元素),小顶堆(堆头是最小元素)

定义:priority_queue<int>que;(默认大顶堆)表示值越大,越先出队

几种基本操作

que.size() 获得元素数量

que.push()

que.pop() 删除优先级最高的元素(堆顶元素,类似于对栈的操作)

que.top()  访问优先级最高的元素

que.empty() 查看堆是否为空

优先队列定义的进阶:

priority_queue<int, vector<int>,  greater<int> > pri_que; 

第一个参数代表其内部的元素类型,第二个参数代表其用什么容器存放元素,第三个参数可以是less<int>表示小于的意思,默认为大顶堆  或是   greater<int> 默认为小顶堆

对于自定义比较方法:

1.重写仿函数(函数对象)

#include<bits/stdc++.h>
#define ll long long
using namespace std;

#define PP pair<int,int>

struct cmp{    
            //重写仿函数
   bool operator()(PP a,PP b)
   {
       return a.first>b.first;
   }

};

int main()
{
     priority_queue<PP,vector<PP>,cmp> q;

     q.push(make_pair(4,6));
     q.push(make_pair(9,4));
     q.push(make_pair(6,1));
     while(!q.empty())
     {
         cout<<q.top().first<<q.top().second;
         q.pop();
     }

    return 0;
}

2.运算符重载:

#include<bits/stdc++.h>
#define ll long long
using namespace std;

#define PP pair<int,int>

struct Node{

    int x,y,z;
    Node(int a,int b,int c)
    {
        x=a,y=b,z=c;
    }
    bool operator<(const Node &a) const   //*****  运算符重载 < ,内置
    {
        return a.z>z;  //按z值降序
    }
};

int main()
{
    priority_queue<Node> q;
    q.push(Node(1,2,3));
    q.push(Node(3,9,1));
    q.push(Node(2,3,4));
    while(!q.empty())
    {
        cout<<q.top().x << endl<<q.top().y <<endl<<q.top().z;
        q.pop();
    }

    return 0;
}

 具体思路如下:

我们选择使用小顶堆,因为每次移动更新元素时,大顶堆都会弹出最大的元素,与我们的目的相悖,所以我们应该使用小顶堆,每次弹出最小的元素即可

具体代码如下:

class Solution {
public:
    class comparison{
        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) {
        vector<int>result;
        unordered_map<int,int>map;
        for(int i:nums){
            map[i]++;
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>,comparison>pri_que;
        for(auto it=map.begin();it!=map.end();it++){
            pri_que.push(*it);
            if(pri_que.size()>k){
                pri_que.pop();
            }
        }
        for(int i=0;i<k;i++){
            result.push_back(pri_que.top().first);
            pri_que.pop();
        }
        return result;
    }
};

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
第二十二天的算法训练主要涵盖了Leetcode题目中的三道题目,分别是Leetcode 28 "Find the Index of the First Occurrence in a String",Leetcode 977 "有序数组的平方",和Leetcode 209 "长度最小的子数组"。 首先是Leetcode 28题,题目要求在给定的字符串中找到第一个出现的字符的索引。思路是使用双指针来遍历字符串,一个指向字符串的开头,另一个指向字符串的结尾。通过比较两个指针所指向的字符是否相等来判断是否找到了第一个出现的字符。具体实现的代码如下: ```python def findIndex(self, s: str) -> int: left = 0 right = len(s) - 1 while left <= right: if s[left == s[right]: return left left += 1 right -= 1 return -1 ``` 接下来是Leetcode 977题,题目要求对给定的有序数组中的元素进行平方,并按照非递减的顺序返回结果。这里由于数组已经是有序的,所以可以使用双指针的方法来解决问题。一个指针指向数组的开头,另一个指针指向数组的末尾。通过比较两个指针所指向的元素的绝对的大小来确定哪个元素的平方应该放在结果数组的末尾。具体实现的代码如下: ```python def sortedSquares(self, nums: List[int]) -> List[int]: left = 0 right = len(nums) - 1 ans = [] while left <= right: if abs(nums[left]) >= abs(nums[right]): ans.append(nums[left ** 2) left += 1 else: ans.append(nums[right ** 2) right -= 1 return ans[::-1] ``` 最后是Leetcode 209题,题目要求在给定的数组中找到长度最小的子数组,使得子数组的和大于等于给定的目标。这里可以使用滑动窗口的方法来解决问题。使用两个指针来表示滑动窗口的左边界和右边界,通过移动指针来调整滑动窗口的大小,使得滑动窗口中的元素的和满足题目要求。具体实现的代码如下: ```python def minSubArrayLen(self, target: int, nums: List[int]) -> int: left = 0 right = 0 ans = float('inf') total = 0 while right < len(nums): total += nums[right] while total >= target: ans = min(ans, right - left + 1) total -= nums[left] left += 1 right += 1 return ans if ans != float('inf') else 0 ``` 以上就是第二十二天的算法训练的内容。通过这些题目的练习,可以提升对双指针和滑动窗口算法的理解和应用能力。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值