347. 前 K 个高频元素 (优先队列 c++)

347. 前 K 个高频元素

难度中等1272收藏分享切换为英文接收动态反馈

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

示例 1:

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

示例 2:

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

 

【C++】优先队列的预备知识 对于我这种初学者来说，一个优先队列就给我搞蒙了，在此记录一下，造福后来人

## 定义

priority_queue<Type, Container, Functional>;

Type是要存放的数据类型

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

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

priority_queue<Type>;

此时默认的容器是vector，默认的比较方式是大顶堆less<type>

*举例*

//小顶堆
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<fruit>,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;

    }
};