Day11| ● 239. 滑动窗口最大值● 347.前 K 个高频元素

239. 滑动窗口最大值

这道题的要点在于思考数据结构的定义。我们要维护一个特殊的队列，保证每次队列开头元素是最大的，那么每次push的时候一定要把尾部比value小的元素pop，这利用deque是很容易实现的，这就保证了我们每次都能pop掉比value更早被pop且比value小的元素，显然这个元素是没用的。pop的话比较一下开头元素是否是应该pop的元素就好了。因为我们可能已经把需要pop的元素删掉了。注意判空操作。

实现三个函数之后这道题就很简单了。

class Solution {
public:
  class myque
  {
    public:
    deque<int> que;
    void push(int value)
    {
       while(!que.empty()&&value>que.back())
       {
        que.pop_back();
       }
       que.push_back(value);
    }
    void pop(int value)
    {
        if(!que.empty()&&que.front()==value)
        que.pop_front();

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

    }
};

347.前 K 个高频元素

这道题的实现难度还是比较高的，要能想到使用小顶堆，也就是priority_queue才行。要注意的是，因为是小顶堆，所以左孩子应该大于右孩子，并且我们使用pair排序的话应该重新定义下比较函数。其实我们用map和sort都能实现这道题不过我们只需要前k个所以最优的解法还是priority_queue。

class Solution {
public:
class mycompair
{
    public:
    bool operator()(const pair<int,int> left,const pair<int,int>right)
    {
        return left.second>right.second;//小顶堆，所以左孩子大于右孩子//
        
    }

};
    vector<int> topKFrequent(vector<int>& nums, int k) {
     vector<int> result(k,-1);
     priority_queue<pair<int,int>,vector<pair<int,int> >,mycompair> que;
     unordered_map<int,int> map;
     for(int i=0;i<nums.size();i++)
     {
        map[nums[i]]++;
     }

     for(auto it=map.begin();it!=map.end();it++)
     {
        que.push(*it);
        if((que.size()>k))
        que.pop();
     }

    for(int i=result.size()-1;i>=0;i--)
    {
          result[i]=que.top().first;
          que.pop();


    }




     return result;
    }
};

bool cmp(const pair<int,int> a,const pair<int,int> b)
    {

        return a.second>b.second ;
    }

class Solution {
public:


    vector<int> topKFrequent(vector<int>& nums, int k) {

        unordered_map<int,int> mp;
        for(int i=0;i<nums.size();i++)
        {
            mp[nums[i]]++;

        }
        vector<pair<int,int> > tmp;
        for(auto it=mp.begin();it!=mp.end();it++)
        {
            tmp.push_back(*it);
        }
        sort(tmp.begin(),tmp.end(),cmp);

        vector<int> result;
        for(int i=0;i<k;i++)
        {
            result.push_back(tmp[i].first);
        }

     return result;
    }
};

或者用map也可以就是时间复杂度和空间复杂度高些不过leetcode能过。