Leetcode347之前K个高频元素

题目：

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。

代码：

方法一——使用最大堆做：

class Solution {
public:
    
void adjustup(vector<int>&nums,int i,map<int,int> m,map<int,int>& indexmap){
    int f=(i+1)/2-1;
    while(f>=0){
        if(m[nums[f]]<m[nums[i]]){
            int t=nums[i];
            nums[i]=nums[f];
            indexmap[nums[f]]=i;
            nums[f]=t;
            indexmap[t]=f;
            i=f;
            f=(i+1)/2-1;
        }else break;
    }
}
void adjustdown(vector<int>&nums,int i,map<int,int> m,map<int,int>& indexmap,int end){
    int index=2*i+1,r=2*i+2;
    while(index<end){
        if(r<end&&m[nums[r]]>m[nums[index]])index=r;
        if(m[nums[i]]<m[nums[index]]){
            int t=nums[i];
            nums[i]=nums[index];
            indexmap[nums[index]]=i;
            nums[index]=t;
            indexmap[t]=index;
            i=index;
            index=2*i+1,r=2*i+2;
        }else break;
    }
}

vector<int> topKFrequent(vector<int>& nums, int k) {
    vector<int> un;
    map<int,int> m;
    int len=nums.size();
    map<int,int> indexmap;

    for(int i=0;i<len;i++){
        if(!m.count(nums[i])){
            un.push_back(nums[i]);
            m[nums[i]]=1;
            indexmap[nums[i]]=int(un.size())-1;
        }else{
            m[nums[i]]+=1;
            if(indexmap[nums[i]]!=0){
                adjustup(un,indexmap[nums[i]],m,indexmap);
            }
        }
    }
    vector<int> res(k,0);
    int length=un.size()-1;
    for(int i=0;i<k;i++){
        res[i]=un[0];
        un[0]=un[length];
        adjustdown(un,0,m,indexmap,length);
        length-=1;
    }
    return res;
}


};

思路：使用indexmap数组记录堆中元素的下标，使用m记录堆中元素的频率；保持一个关于全部元素的最大堆，每次push，如果它不是第一名，那么就adjust up；最后，adjust down来取出频率前k大的元素；

方法二——使用最小堆：

class Solution {
public:
    
void adjustup(vector<int>& un,map<int,int>& m,map<int,int>& indexmap,int index){

    int f=(index+1)/2-1;
    while(f>=0&&m[un[index]]<m[un[f]]){
        int t=un[f];
        un[f]=un[index];
        indexmap[un[index]]=f;
        un[index]=t;
        indexmap[t]=index;
        index=f;
        f=(index+1)/2-1;
    }
}

void adjustdown(vector<int>& un,map<int,int>& m,int i,map<int,int>& indexmap,int end){
    int index=2*i+1,r=2*i+2;
    while(index<end){
        if(r<end&&m[un[r]]<m[un[index]])index=r;
        if(m[un[i]]>m[un[index]]){
            int t=un[i];
            un[i]=un[index];
            indexmap[un[index]]=i;
            un[index]=t;
            indexmap[t]=index;
            i=index;
            index=2*i+1;
        }else break;
    }
}

vector<int> topKFrequent(vector<int>& nums, int k) {
    int len=int(nums.size()),count=0;
    vector<int> un(k,0);
    map<int,int> m={};
    map<int,int> indexmap={};
    for(int i=0;i<len;i++){

        if(count<k){
            if(!m.count(nums[i])||m[nums[i]]==0){
                m.insert(pair<int,int>(nums[i],1));
                un[count]=nums[i];
                indexmap[nums[i]]=count;
                adjustup(un,m,indexmap,count);
                count++;
            }else{
                m[nums[i]]+=1;
                adjustdown(un,m,indexmap[nums[i]],indexmap,count);
            }
        }else{
            m[nums[i]]+=1;
            if(!indexmap.count(nums[i])){
                if(m[nums[i]]>m[un[0]]){
                indexmap.erase(un[0]);
                un[0]=nums[i];
                indexmap[nums[i]]=0;
                adjustdown(un,m,0,indexmap,count);}
            }else{
                adjustdown(un,m,indexmap[nums[i]],indexmap,count);
            }
            }
        }

    return un;
}

};

想法：构建一个最小堆，如果堆的size小于k，那么判断新来的元素的频率，如果是0，那么m+1,adjust up，否则m+1,adjust down; 堆的size大于k，判断新来的元素是否已经在，如果在，那么m+1,adjust down,如果不在，判断新来的元素和顶端的频率，如果大于顶端，那么顶端=新来的元素，adjust down；

方法三——使用优先权队列这个接口：

class Solution {
public:

static bool cmp(pair<int,int>&m, pair<int,int>&n){
    return m.second>n.second;
}

vector<int> topKFrequent(vector<int>&nums,int k){
    unordered_map<int,int> occurences;
    for(auto& v:nums){
        occurences[v]++;
    }
    //pair的第一个元素代表数组的值，第二个元素代表了该值出现的次数
    priority_queue<pair<int,int>,vector<pair<int,int>>, decltype(&cmp)> q(cmp);
    for(auto& [num,count]:occurences){
        if(q.size()==k){
            if(q.top().second<count){
                q.pop();
                q.emplace(num,count);
            }
        }else{
            q.emplace(num,count);
        }
    }
    vector<int> ret;
    while(!q.empty()){
        ret.emplace_back(q.top().first);
        q.pop();
    }
    return ret;
}

};

思路：首先遍历一遍统计出现次数的频率，然后加在优先权队列中，排就让他排；

方法四——哈希表存储频率+快排找出topk；

代码：

class Solution {
public:

void qsort(vector<pair<int,int>>& v,int start,int end,vector<int>& ret,int k){
    int picked=rand()%(end-start+1)+start;
    swap(v[picked],v[start]);
    int pivot=v[start].second;
    int index=start;
    for(int i=start+1;i<=end;i++){
        if(v[i].second>=pivot){
            swap(v[index+1],v[i]);
            index++;
        }
    }
    swap(v[start],v[index]);
    if(k<=index-start){
        qsort(v,start,index-1,ret,k);
    }else{
        for(int i=start;i<=index;i++){
            ret.push_back(v[i].first);
        }
        if(k>index-start+1){
            qsort(v,index+1,end,ret,k-(index-start+1));
        }
    }
}

vector<int> topKFrequent(vector<int>& nums,int k){
    unordered_map<int,int> occurrences;
    for(auto& v :nums){
        occurrences[v]++;
    }
    vector<pair<int, int>> values;
    for (auto& kv: occurrences) {
        values.push_back(kv);
    }

    vector<int> ret;
    qsort(values,0,values.size()-1,ret,k);
    return ret;
}

};

思路：先用哈希表存储频率，然后使用快排找出topk；