347. Top K Frequent Elements

问题描述：

Given a non-empty array of integers, return the k most frequent elements.

For example,

 

Given [1,1,1,2,2,3] and k = 2, return [1,2].

Note: 

 

• You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
• Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

 

注意： 给定的数组是无序的。 有下面两种方法，分别进行介绍。

 

• 思路1: Bucket sort（map+bucket_sort）

 

Step1: 使用map<int , int >统计每个数在数组中出现的次数。

Step2: 借用桶排序的思想， 申请 sizeof(array)+1 个桶（因为数组中出现频次最多可能就是 sizeof(array)+1) 。 桶是频次n， 桶内存放的是出现频次为n的数组元素 arr1, arr2…arrx。

Step3: 从后往前遍历桶，依次将桶内的元素取出来放到向量里，直到向量的个数为k。

 

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
       map<int,int> num_freq;
    
    //step1
    for (int num : nums)
        num_freq[num]++;
    vector<vector<int>> buckets(nums.size()+1);
    //step2
    for (auto bucket: num_freq)
        buckets[bucket.second].push_back(bucket.first);
    //step3
    vector<int> val;
    for (int i=(int)buckets.size()-1; i>=0 && val.size()<k; i--)
    {
        for(auto eachBucket : buckets[i])
        {
            val.push_back(eachBucket);
            if (val.size()>=k)
                break;
        }
        
    }
    return val;
    }
};

 

总结： 空间复杂度：O(n), 时间复杂度：O（n）(n为数组元素的个数)

 

• 思路2:  Heap Sort

借用priotity queue维持一个最小堆，其中堆的大小为K。 若堆的大小大于K， 则调整出列。

vector<int> topKFrequent(vector<int>& nums, int k) {
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
    
    map<int,int> cnt;
    for (auto count : nums) cnt[count]++;
    
    for (auto km : cnt)
    {
        pq.push({km.second,km.first});
        if(pq.size()>k)
            pq.pop();
    }
    
    vector<int> res;
    while (!pq.empty())
    {
        res.push_back(pq.top().second);
        pq.pop();
    }
    return res;
}

时间复杂度： O(Nlogk)

上面的堆排序结果是不稳定的，比如 原始向量是 {1，1，1，2，2，3} ，输出的值是{2，1}， 而并不是我们预期的{1, 2}。

若想得到稳定的排序结果，该怎么做呢？

可以使用最大堆，堆的大小为map.size()-k。若超过map.size()-k, 则将堆的最大值放入向量里。

vector<int> topKFrequent(vector<int>& nums, int k) {
    map<int,int> counts;
    for(int num:nums)
        counts[num]++;
    
    priority_queue<pair<int,int>> pq;
    
    vector<int> res;
    for(auto ct: counts)
    {
        pq.push({ct.second, ct.first});
        if(pq.size()>(counts.size()-k))
        {
            res.push_back(pq.top().second);
            pq.pop();
        }
    }
    return res;
}