旅游网站建设背景/无线网络优化是做什么的

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 <= 10⁵
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)原题链接
欢迎大家和我沟通交流(✿◠‿◠)