leetcode：347. 前 K 个高频元素

题目来源

• leetcode：347. 前 K 个高频元素

题目描述

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {

    }
};

题目解析

优先队列

• 先弄出一张词频表
• 然后维护一个大小为k的小根堆，次数小的放到顶部（最薄弱的在顶部）
• 然后遍历词频表，如果小根堆个数 大于k时，就干掉门槛（出现次数最少的那个）

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
      //1.map记录元素出现的次数
        unordered_map<int,int>map;//两个int分别是元素和出现的次数
        for(auto& c:nums){
            map[c]++;
        }
       //2.利用优先队列，将出现次数排序
        //自定义优先队列的比较方式，小顶堆
        struct myComparison{
            bool operator()(pair<int,int>&p1,pair<int,int>&p2){
                return p1.second>p2.second;//小顶堆是大于号
            }
        };
        //创建优先队列
        priority_queue<pair<int,int>,vector<pair<int,int>>,myComparison> q;
        //遍历map中的元素
        //1.管他是啥，先入队列，队列会自己排序将他放在合适的位置
        //2.若队列元素个数超过k，则将栈顶元素出栈（栈顶元素一定是最小的那个）
        for(auto& a:map){
            q.push(a);
            if(q.size()>k){
               q.pop(); 
            }
        }
        //将结果导出
        vector<int>res;
        while(!q.empty()){
            res.emplace_back(q.top().first);
            q.pop();
        }
        return res;

    }
};

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
       // 先建立出现次数的元素
        std::unordered_map<int, int> m;
        for(auto n : nums){
            ++m[n];
        }
        
        // 用堆排序
        std::priority_queue<pair<int, int>> q;
        for(auto it : m){
            q.push({it.second, it.first});
        }
        
        // 将结果导出
        std::vector<int> vec;
        for (int i = 0; i < k; ++i) {
            vec.push_back(q.top().second);
            q.pop();
        }
        return vec;
    }
};

桶排序

还可以用桶排序：

• 先建立好数字和其出现的次数的元素
• 在按照其出现的次数将数字放到对应的位置中去
• 最后从桶的后面向前遍历，最先得到的就是出现次数最多的数字，找到k个后返回即可，参见代码如下：

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> m;
        vector<vector<int>> bucket(nums.size() + 1);
        vector<int> res;
        for (auto a : nums) ++m[a];
        for (auto it : m) {
            bucket[it.second].push_back(it.first);
        }
        for (int i = nums.size(); i >= 0; --i) {
            for (int j = 0; j < bucket[i].size(); ++j) {
                res.push_back(bucket[i][j]);
                if (res.size() == k) return res;
            }
        }
        return res;
    }
};

关于进阶

基于快速排序（最优解）

在对数组arr[l...r]做快速排序的过程中，我们首先将数组划分为两个部分arr[I, ... q - 1] 与arr[q + 1...j]，并使得arr[I, ... q - 1]中的每一个值都不超过arr[q]，且 arr[q+1…j] 中的每一个值都大arr[q]。

于是，我们根据k与左侧子数组arr[i...q - 1]的长度（为 q-i）的大小关系：

• 如果k <= q - i，则数组arr[l...r]前k大的值，就等于子数组arr[i…q−1] 前 k 大的值。
• 否则，数组arr[l…r] 前 k 大的值，就等于左侧子数组全部元素，加上右侧子数组arr[q+1…j] 中前 k - (q - i) 大的值。

class Solution {
    void qsort(vector<pair<int, int>>& v, int start, int end, vector<int>& ret, int k) {
        int picked = rand() % (end - start + 1) + start;
        std::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));
            }
        }
    }
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        std::unordered_map<int, int> freq;
        for (auto& v : nums) {
            freq[v]++;
        }

        std::vector<std::pair<int, int>> values;
        for(auto &kv : freq){
            values.emplace_back(kv);
        }
        
        std::vector<int>ret;
        qsort(values, 0, values.size() - 1, ret, k);
        return ret;
    }
};

类似题目

• leetcode：215. 无序数组中第k大的元素（排序后位于第n-k索引上的数） Kth Largest Element in an Array
• leetcode：347. 无序数组中前 K 个高频元素 Top K Frequent Elements
• leetcode：451-根据字符出现频率排序 Sort Characters By Frequency
• leetcode：692. 前K个高频单词