力扣347. 前 K 个高频元素与C++stl优先队列(大小根堆)的自定义排序用法总结

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

示例 1:

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

示例 2:

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

提示：

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

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

初次想法
用map+vector的sort 时间nlogn 但不符合题意 题目要求优于nlogn

struct pairnum {//pairnum用来存储元素
	int a;//a表示数字
	int b;//b表示该数字出现的次数
};
static bool cmp(const pairnum &x,const pairnum &y) {
	return x.b > y.b;//自定义排序,以出现次数降序排序
}
    vector<int> topKFrequent(vector<int>& nums, int k) {//求前k高频率
	vector<pairnum>sum;//sum存放元素
	int n = nums.size();
	unordered_map<int, int>mp;//mp用来记录已经遍历的数字在vector中的下标
	for (int i = 0; i < n; i++) {
		if (mp.count(nums[i]) == 0) {//未出现过的元素要插入map
			pairnum newpair;
			newpair.a = nums[i];
			newpair.b = 1;
			sum.push_back(newpair);
			mp[nums[i]] = sum.size() - 1;
		}
		else sum[mp[nums[i]]].b++;
	}
	sort(sum.begin(), sum.end(), cmp);
	vector<int> answer;
	for (int i = 0; i < k; i++) answer.push_back(sum[i].a);
	return answer;
}

正确思路
像取k个数这种,用小根堆,时间可以达到O(nlogk),优于nlogn
【C++】优先队列的预备知识 对于我这种初学者来说，一个优先队列就给我搞蒙了，在此记录一下，造福后来人
定义:
priority_queue<Type, Container, Functional>;

Type是要存放的数据类型

Container是实现底层堆的容器，必须是数组实现的容器，如vector、deque

Functional是比较方式/比较函数/优先级

priority_queue<Type>;

此时默认的容器是vector，默认的比较方式是大顶堆less<type>
即每次pop的都是最大值

举例:

//小顶堆
priority_queue <int,vector<int>,greater<int> > q;
//大顶堆
priority_queue <int,vector<int>,less<int> >q;
//默认大顶堆
priority_queue<int> a;

//pair
priority_queue<pair<int, int> > a;
pair<int, int> b(1, 2);
pair<int, int> c(1, 3);
pair<int, int> d(2, 5);
a.push(d);
a.push(c);
a.push(b);
while (!a.empty()) 
{
   cout << a.top().first << ' ' << a.top().second << '\n';
   a.pop();
}
//输出结果为：
2 5
1 3
1 2

常用函数:

top()
pop()
push()
emplace()
empty()
size()

自定义比较方式
当数据类型并不是基本数据类型，而是自定义的数据类型时，就不能用greater或less的比较方式了，而是需要自定义比较方式

在此假设数据类型是自定义的水果：

struct fruit
{
	string name;
	int price;
};

有两种自定义比较方式的方法，如下

1.重载运算符
重载”<”
若希望水果价格高为优先级高，则

//大顶堆
struct fruit
{
	string name;
	int price;
	friend bool operator < (fruit f1,fruit f2)
	{
		return f1.peice < f2.price;
	}
};

若希望水果价格低为优先级高

//小顶堆
struct fruit
{
	string name;
	int price;
	friend bool operator < (fruit f1,fruit f2)
	{
		return f1.peice > f2.price;  //此处是>
	}
};

2.仿函数
若希望水果价格高为优先级高，则若希望水果价格高为优先级高，则

//大顶堆
struct myComparison
{
	bool operator () (fruit f1,fruit f2)
	{
		return f1.price < f2.price;
	}
};

//此时优先队列的定义应该如下
priority_queue<fruit,vector,myComparison> q;

此题正确代码如下：

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;

    }
};