347. 前 K 个高频元素

topk问题，不是大顶堆就是小顶堆。直接上优先队列，这里要自定义比较函数。维护出现频率最高的k个元素，我们维护一个k个元素的小顶堆，为什么用小顶堆，因为出现频率最少的可以在堆顶，每次新进来的元素优先和堆顶的比，如果比堆顶的出现频率高，堆顶的就可以被pop了，加入新的。最后留下的k个元素就是频率最高的k个。

class Solution {
public:
    struct cmp{
        bool operator()(const pair<int,int>& a, const pair<int,int>& b){
            return a.second > b.second;//如果为false则交换位置，证明a比较小没资格在前面，就把大的换到前面。大的在队列前的叫做小顶堆，堆顶是队列最后一个元素
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        //时复必须是O(nlogn)
        //nlogn不是排序就是和二分有关系
        //先遍历一遍用map记录出现次数,再维护一个小顶堆，如果出现次数比堆顶多，就替换掉堆顶，最后剩下的k个数字就是剩下最多的k个
        unordered_map<int,int> ma;
        for(auto x : nums){
            ma[x]++;
        }
        //优先队列的三个模板参数分别是数据类型，vector加数据类型，比较函数
        priority_queue<pair<int,int>,vector<pair<int,int>>,cmp> q;
        for(unordered_map<int,int>::iterator it = ma.begin(); it!=ma.end();++it){
            if(q.size() < k){
                q.push(make_pair(it->first,it->second));
            }
            else{
                if(q.top().second < it->second){
                    q.pop();
                    q.push(make_pair(it->first,it->second));
                }
            }
        }
        vector<int> res;
        while(!q.empty()){
            res.push_back(q.top().first);
            q.pop();
        }
        return res;
    }
};

二刷，一定要记住，优先队列的自定义比较函数怎么写
模板：加入优先队列中比较的是pair<int,int>
这个就定义了一个小顶堆，我们将大的放前面，堆顶是在后面的

struct cmp{
	bool operator()(const pair<int,int>& a, const pair<int,int>& b){
		return a.second > b.second;
	}

class Solution {
public:
    struct cmp{
        //优先队列，堆顶在最后面，所以我们将出现频率最少的放后面
        bool operator()(pair<int,int> a, pair<int,int> b){
            //true就不交换
            return a.second > b.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        //O(nlogn)排序的时间复杂度
        if(nums.size() < k) return vector<int>{};
        //可以用hash记录每个数字出现的次数，然后维护一个k个元素的优先队列，然后自定义比较函数，根据hash来定义比较函数，维护的是一个小顶堆，出现次数少的在堆顶
        priority_queue<pair<int,int>,vector<pair<int,int>>,cmp> q;
        unordered_map<int,int> ma;
        for(int i = 0; i < nums.size(); ++i){
            ma[nums[i]]++;
        }
        for(unordered_map<int,int>::iterator it = ma.begin(); it != ma.end(); it++){
            if(q.size() <k){
                q.push(make_pair(it->first,it->second));
            }
            else{
                if(q.top().second < it->second){
                    q.pop();
                    q.push(make_pair(it->first,it->second));
                }
            }
        }
        vector<int> res;
        while(!q.empty()){
            res.push_back(q.top().first);
            q.pop();
        }
        return res;
    }
};

根据出现次数有关的可以用外部排序，也就是桶排序来控制，典型的空间换时间。因为要去重复的数字，所以遍历map就行了

class Solution {
public:
    struct cmp{
        bool operator()(const pair<int,int>& a, const pair<int,int>& b){
            //堆排序，堆顶元素在后面，前k高的元素，用小顶堆，最后剩下的k个就是最高的k个
            return a.second > b.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        //还是堆排序，根据出现次数来排序
        //堆里的元素是pair分别存数字和出现次数，一定要用pair，这样写比较函数简单，如果不是pair要根据unordered_map来写比较函数是不行的

        priority_queue<pair<int,int>,vector<pair<int,int>>,cmp> q;
        unordered_map<int,int> ma;
        //要用unordered_set来存nums，不然会有重复的
        //不用unordered_set！！直接遍历unordered_map就行了
        for(int i = 0; i < nums.size(); ++i){
            ma[nums[i]]++;
        }
        for(auto it = ma.begin(); it != ma.end(); ++it){
            if(q.size() < k){
                q.push(make_pair(it->first,it->second));
            }
            else{
                if(q.top().second < it->second){
                    q.pop();
                    q.push(make_pair(it->first,it->second));
                }
            }
        }
        vector<int> res;
        while(!q.empty()){
            res.push_back(q.top().first);
            q.pop();
        }
        return res;
    }
};