LeetCode 热题 100_前 K 个高频元素(73_347)
- 题目描述:
- 输入输出样例:
- 题解:
- 解题思路:
- 思路一(哈希表+排序):
- 思路二(哈希表+优先队列(小根堆)):
- 代码实现
- 代码实现(思路一(哈希表+排序)):
- 代码实现(思路二(哈希表+优先队列(小根堆))):
- 以思路二为例进行调试
- 部分代码解读
题目描述:
给你一个整数数组 nums 和一个整数 k ,请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
输入输出样例:
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:
输入: nums = [1], k = 1
输出: [1]
提示:
1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一,换句话说,数组中前 k 个高频元素的集合是唯一的
题解:
解题思路:
思路一(哈希表+排序):
1、创建一个哈希表,key来存储数组中元素,value存储对应key出现的次数。对value进行快速排序。提取排序后,前k个元素的值。
2、复杂度分析:
① 时间复杂度:O(nlogn),n为数组中元素的个数
遍历 nums 数组中的每个元素,将其出现的频率存储到 unordered_map 中。这个过程的时间复杂度是 O(n)。
将 unordered_map 的元素复制到 vector 中,这个操作的时间复杂度是 O(n)。
对 tmp 中的元素进行排序,排序的时间复杂度是 O(n log n)。
从排序后的 tmp 中选择前 k 个元素并将它们添加到 ans 中,这个过程的时间复杂度是 O(k)。
② 空间复杂度:O(n + log n),除返回答案的空间外,unordered_map 的空间复杂度是 O(n),vector<pair<int, int>> tmp 的空间复杂度是 O(n)。快速排序,空间复杂度是 O(log n)
思路二(哈希表+优先队列(小根堆)):
1、创建一个哈希表,key来存储数组中元素,value存储对应key出现的次数。创建可以维持 k 个元素的小根堆(根据value大小进行插入),这样在插入元素大于 k 时可以将堆顶的元素移出(优先级队列就是一个披着队列外衣的堆)。
2、复杂度分析
① 时间复杂度:O(n log k),其中 n 是输入数组的长度,k 是要求的前 k 个频率最高的元素。遍历 nums 数组并将每个元素的出现频率存入 unordered_map中为 O(n)。将元素插入最小堆O(n log k)。从堆中弹出元素并构建结果数组 O(k log k)。
② 空间复杂度: O(n + k),哈希表存储每个数字及其频率,最坏情况下需要存储所有 n 个数字 O(n)。最小堆的最大大小为 O(k)。
代码实现
代码实现(思路一(哈希表+排序)):
class Solution1 {
public:// 函数接受一个整数数组 nums 和一个整数 k, 返回出现频率最高的 k 个元素vector<int> topKFrequent(vector<int>& nums, int k) {// 使用 unordered_map 来统计每个数字出现的频率unordered_map<int,int> count;// 遍历 nums 数组,统计每个数字的出现次数for (int &num : nums){count[num]++; // 每遇到一个 num,就将对应的频率加 1}// 将 unordered_map 中的元素复制到一个 vector 中,以便进行排序vector<pair<int,int>> tmp(count.begin(), count.end());// 对 tmp 中的元素进行排序,按照频率降序排序// 使用 lambda 表达式作为排序规则sort(tmp.begin(), tmp.end(), [](pair<int,int>& a, pair<int,int>& b) { return a.second > b.second; // 如果 a 的频率大于 b 的频率,返回 true });// 创建一个结果 vector 来存放出现频率最高的 k 个元素vector<int> ans;// 选择排序后的前 k 个元素的第一个值(即数字)到 ans 中for (int i = 0; i < k; i++){ans.emplace_back(tmp[i].first); // 将 tmp 中的第 i 个元素的第一个值添加到 ans}return ans; // 返回结果}
};
代码实现(思路二(哈希表+优先队列(小根堆))):
class Solution2 {
private:// 自定义比较器类,用于堆的排序class Compare {public:// 重载比较运算符,按照频率(second)大小进行比较bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {// 如果左边的频率大于右边,返回true。这样堆中频率小的元素会排在堆顶。return lhs.second > rhs.second;}};public:// topKFrequent 函数返回数组中出现频率前k大的元素vector<int> topKFrequent(vector<int>& nums, int k) {// 使用 unordered_map 来存储每个元素及其出现的频率unordered_map<int, int> count;// 统计数组中每个元素的出现次数for (int i = 0; i < nums.size(); i++) {count[nums[i]]++;}// 创建一个最小堆来保存频率前 k 大的元素// priority_queue 的第三个参数是自定义的比较器 Compare,确保堆顶是频率最小的元素priority_queue<pair<int, int>, vector<pair<int, int>>, Compare> min_head;// 遍历计数哈希表,将每个元素(和其频率)加入到堆中for (auto& i : count) {min_head.push(i); // 将元素及其频率压入堆// 如果堆的大小超过了 k,则弹出堆顶元素(频率最小的元素)if (min_head.size() > k) {min_head.pop();}}// 用来存储最终的前 k 个频率最大的元素vector<int> ans(k);// 从堆中依次弹出元素,存入答案数组// 由于堆顶是频率最小的元素,因此我们从堆顶弹出并将元素存入结果数组for (int i = k - 1; i >= 0; i--) {ans[i] = min_head.top().first; // 获取堆顶元素的值(即数字)min_head.pop(); // 弹出堆顶元素}return ans; // 返回包含频率前 k 大的元素的数组}
};
以思路二为例进行调试
#include<iostream>
#include <vector>
#include<unordered_map>
#include<algorithm>
#include <queue>
using namespace std;class Solution2 {
private:// 自定义比较器类,用于堆的排序class Compare {public:// 重载比较运算符,按照频率(second)大小进行比较bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {// 如果左边的频率大于右边,返回true。这样堆中频率小的元素会排在堆顶。return lhs.second > rhs.second;}};public:// topKFrequent 函数返回数组中出现频率前k大的元素vector<int> topKFrequent(vector<int>& nums, int k) {// 使用 unordered_map 来存储每个元素及其出现的频率unordered_map<int, int> count;// 统计数组中每个元素的出现次数for (int i = 0; i < nums.size(); i++) {count[nums[i]]++;}// 创建一个最小堆来保存频率前 k 大的元素// priority_queue 的第三个参数是自定义的比较器 Compare,确保堆顶是频率最小的元素priority_queue<pair<int, int>, vector<pair<int, int>>, Compare> min_head;// 遍历计数哈希表,将每个元素(和其频率)加入到堆中for (auto& i : count) {min_head.push(i); // 将元素及其频率压入堆// 如果堆的大小超过了 k,则弹出堆顶元素(频率最小的元素)if (min_head.size() > k) {min_head.pop();}}// 用来存储最终的前 k 个频率最大的元素vector<int> ans(k);// 从堆中依次弹出元素,存入答案数组// 由于堆顶是频率最小的元素,因此我们从堆顶弹出并将元素存入结果数组for (int i = k - 1; i >= 0; i--) {ans[i] = min_head.top().first; // 获取堆顶元素的值(即数字)min_head.pop(); // 弹出堆顶元素}return ans; // 返回包含频率前 k 大的元素的数组}
};int main(int argc, char const *argv[])
{vector<int> nums={1,1,1,2,2,3};int k=2;Solution2 s2;vector<int> ans=s2.topKFrequent(nums,k);cout<<"[";for (int i = 0; i < ans.size(); i++){cout<<ans[i];if (i!=ans.size()-1){cout<<",";}}cout<<"]";return 0;
}
部分代码解读
比较器是 lambda 表达式
sort(tmp.begin(), tmp.end(), [](pair<int,int>& a, pair<int,int>& b) { return a.second > b.second; // 如果 a 的频率大于 b 的频率,返回 true
});
最常见的比较器是 lambda 表达式,因为它:
非常简洁,适用于大多数场景,特别是排序、查找等常用算法。
可以在需要时动态定义比较逻辑,而不需要额外定义函数或类。
Compare:自定义比较器类 (Functor)
class Compare {
public:// 重载比较运算符,按照频率(second)大小进行比较bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {// 如果左边的频率大于右边,返回true。这样堆中频率小的元素会排在堆顶。return lhs.second > rhs.second;}
};
priority_queue<pair<int, int>, vector<pair<int, int>>, Compare> min_head;
Compare:自定义比较器类 (Functor)
pair<int, int> 是一个由两个 int 类型元素组成的模板类,它可以存储一对值。
这里的 vector<pair<int, int>> 表示堆的底层容器是一个 pair<int, int> 类型的 vector。
优点:
复用性强:可以在多个地方使用相同的比较逻辑,不需要每次都重新定义。
性能较好:在某些情况下,函数对象(类)可能比 lambda 表达式稍微高效,因为它可以在编译时优化。
适合复杂逻辑:当比较逻辑较复杂时,使用类比 lambda 更加清晰和易于管理。
缺点:
代码较多:需要定义一个额外的类,增加了代码的复杂性,尤其是对于简单的比较。
LeetCode 热题 100_前 K 个高频元素(73_347)原题链接
欢迎大家和我沟通交流(✿◠‿◠)