栈与队列 | 8 347.前 K 个高频元素（优先队列、map遍历）

本文记录的是刷题过程中的重要概念和笔记。如有侵权，请联系删除。

347.前 K 个高频元素

力扣题目链接(opens new window)
https://leetcode.cn/problems/top-k-frequent-elements/

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

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

输入: nums = [1], k = 1
输出: [1]
提示：

你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 $O(n\log n)$ , n 是数组的大小。
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。

思路

这道题目主要涉及到如下三块内容：

要统计元素出现频率
对频率排序
找出前K个高频元素

统计元素

首先统计元素出现的频率，这一类的问题可以使用map来进行统计。

优先级队列

优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。

而且优先级队列内部元素是自动依照元素的权值排列。

缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。

为什么不用快排

使用快排要将map转换为vector的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。

使用小顶堆还是大顶堆？

有的同学一想，题目要求前 K 个高频元素，那么果断用大顶堆啊。

那么问题来了，定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢。

而且使用大顶堆就要把所有元素都进行排序，那能不能只排序k个元素呢？

所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

补充：sort函数

sort函数进行排序的时间复杂度为n*log2n，比冒泡之类的排序算法效率要高，sort函数包含在头文件为#include的c++标准库中。

补充：优先队列

普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。

在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有**最高级先出 （first in, largest out）**的行为特征。

首先要包含头文件#include<queue>, 他和queue不同的就在于我们可以自定义其中数据的优先级, 让优先级高的排在队列前面,优先出队。

优先队列具有队列的所有特性，包括队列的基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的。

和队列基本操作相同:

• top 访问队头元素
• empty 队列是否为空
• size 返回队列内元素个数
• push 插入元素到队尾 (并排序)
• emplace 原地构造一个元素并插入队列
• pop 弹出队头元素
• swap 交换内容

定义：priority_queue<Type, Container, Functional>
Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 就是比较的方式。

当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶堆。
一般是：

1 //升序队列，小顶堆
2 priority_queue <int,vector<int>,greater<int> > q;
3 //降序队列，大顶堆
4 priority_queue <int,vector<int>,less<int> >q;
5 
6 //greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）

大小顶堆写法

快排的cmp函数的时候，return left>right 就是从大到小，return left<right 就是从小到大。

优先级队列的定义正好反过来了，可能和优先级队列的源码实现有关（我没有仔细研究），我估计是底层实现上优先队列队首指向后面，队尾指向最前面的缘故！

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

自定义比较方式

系统定义的数据类型为基本数据类型，如int，float，double等。

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

假设数据类型是一个类：student，包含姓名和成绩

class student
{
public:
   string name;
   int score;
}

若希望成绩越高，优先级越高，则定义大顶堆。定义方式如下：

自定义方式1: 重载运算符

重载 “<”

class student
{
public:
	string name;
	int score;
	friend bool operator < (student s1, student s2)
	{
		return s1.score < s2.score;
	}
};

友元函数 friend
在定义一个类的时候，可以把一些函数（包括全局函数和其他类的成员函数）声明为“友元”，这样那些函数就成为该类的友元函数，在友元函数内部就可以访问该类对象的私有成员了。

自定义方式2: 重写仿函数(重点)

class student
{
public:
	string name;
	int score;
};
 
//大顶堆
class myComparison
{
public:
	bool operator () (student s1, student s2)
	{
		return s1.score < s2.score;
	}
};

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

版权声明：本文为CSDN博主「好人好事代表nxx」的原创文章，遵循CC 4.0
BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_40286920/article/details/126027995

补充：【c++】 unordered_map4种遍历方式

首先定义个 unordered_map

unordered_map<int,int> map={
        pair<int,int>(1,2),
        pair<int,int>(3,4)
    };

方式一：值传递遍历

for(pair<int,int> kv:map){
        cout<<kv.first<<kv.second<<endl;
    }

使用auto

for(auto kv:map){
        cout<<kv.first<<kv.second<<endl;
    }

方式二：引用传递遍历

注意：要加const

for(const pair<int,int>& kv:map){
        cout<<kv.first<<kv.second<<endl;
    }

const加里面也是可以的

for(pair<const int,int>& kv:map){
        cout<<kv.first<<kv.second<<endl;
    }

使用auto

for(auto& kv:map){
        cout<<kv.first<<kv.second<<endl;
    }

方式三：使用迭代器遍历

for(unordered_map<int,int>::iterator it=map.begin();it!=map.end();it++){
        cout<<it->first<<it->second<<endl;
    }

使用auto

for(auto it=map.begin();it!=map.end();it++){
        cout<<it->first<<it->second<<endl;
    }

方式四：结构化绑定(c++17特性)

值传递

for(auto [k,v]:map){
        cout<<k<<v<<endl;
    }

引用传递

for(auto& [k,v]:map){
        cout<<k<<v<<endl;
    }

其中，如果只想使用键,值可以用_代替

for(auto& [k,_]:map){
        cout<<k<<endl;
    }

同理，如果指向只用值，键可以用_代替

for(auto& [_,v]:map){
        cout<<v<<endl;
    }

版权声明：本文为CSDN博主「菊头蝙蝠」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_21539375/article/details/122003559