力扣日记10.31-【栈与队列篇】前 K 个高频元素

力扣日记：【栈与队列篇】前 K 个高频元素

日期：2023.10.31
参考：代码随想录、力扣

347. 前 K 个高频元素

题目描述

难度：中等

给你一个整数数组 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 个高频元素的集合是唯一的

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

题解

class Solution {
#define SOLUTION 2
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
#if SOLUTION == 1
        // 时间复杂度: O(n) + O(n) + O(nlogn) + O(k) = O(nlogn)
        // 空间复杂度: O(n+n)
        unordered_map<int, int> cnt;
        for (const auto& n: nums) {
            cnt[n]++;
        }
        // 将哈希表的内容复制到 vector
        // 使用迭代器范围构造函数（iterator range constructor）创建 sortedVector
        // 这个构造函数接受两个迭代器，它会遍历 cnt 中的元素，然后复制它们到 sortedVector 中
        vector<pair<int, int>> sortedVector(cnt.begin(), cnt.end());

        // 按第二个值的大小对 vector 进行排序(从大到小)
        sort(sortedVector.begin(), sortedVector.end(), 
            [](const pair<int, int>& a, const pair<int, int>& b) { // 匿名函数作为比较器参数
                return a.second > b.second; // 前者大于后者时返回true，表示前者应该在后者前面（大在前、小在后）
            });

        // 取前k个元素
        int count = 0;
        vector<int> result;
        for (const auto& pair : sortedVector) {
            result.push_back(pair.first);
            count++;
            if (count >= k) break;
        }
        return result;
    }
#elif SOLUTION == 2
        // unordered_map + 小顶堆
        // O(nlogk), O(n+k)
        // 之所以用堆，是因为没必要对n个元素都进行排序，只需要维护前k个元素即可

        // 1. 首先用map遍历一遍数组，确定每个数出现的频率
        unordered_map<int, int> cnt;
        for (const auto& n: nums) {
            cnt[n]++;
        }
        // 2. 使用小顶堆遍历map，维护出现频率最高的前k个元素
        // 小顶堆：本质是一个二叉树，每个父结点的值小于子结点，即根结点的值是最小的，值从小到大排列
        // 关于为什么用小顶堆而不是用大顶堆：
        /*
            如果是大顶堆的话，由于其仅维护k个元素，每次push进元素时都需要pop掉根结点元素
            而根结点是值最大的元素，这样的话会导致最后大顶堆中都是出现频率最低的前k个元素
            所以要用小顶堆，每次pop元素弹出值最小的元素，维护出现频率最高的前k个元素
        */
        // 小顶堆通过优先级队列实现
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = cnt.begin(); it != cnt.end(); it++) {
            pri_que.push(*it); // 把it指向的放进队列
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }
        // 3. 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
    // 小顶堆
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second; // 为什么是>(大的在前，小的在后???)
        }
    };
#endif
};

复杂度

• 哈希map + 快排：
  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(n)
• 哈希map + 小顶堆
  • 时间复杂度：O(nlogk)
  • 空间复杂度：O(n)

思路总结

• 解法1：哈希map + 快排
  • 哈希map不能直接排序，要转换为vector才能进行排序
    • 1.将哈希表的内容复制到 vector
    • 2.使用迭代器范围构造函数（iterator range constructor）创建 sortedVector
      • 这个构造函数接受两个迭代器，它会遍历 cnt 中的元素，然后复制它们到 sortedVector 中
      • vector> sortedVector(cnt.begin(), cnt.end());
    • 3.按第二个值的大小对 vector 进行排序(从大到小)

    sort(sortedVector.begin(), sortedVector.end(), 
        [](const pair<int, int>& a, const pair<int, int>& b) { // 匿名函数作为比较器参数
            return a.second > b.second; // 前者大于后者时返回true，表示前者应该在后者前面（大在前、小在后）
        });
    

• 解法2：哈希map + 小顶堆
  • 之所以用小顶堆而不用快排，是因为没必要对n个元素都进行排序，只需要维护前k个元素即可（快排需要对n个元素进行排序，O(nlogn)，小顶堆每次pop和push一个元素只需要logk，即对所有元素的总时间复杂度为O(nlogk)
  • 思路步骤：
  • 1.首先用map遍历一遍数组，确定每个数出现的频率
  • 2.使用小顶堆遍历map，维护出现频率最高的前k个元素
    • 小顶堆：本质是一个二叉树，每个父结点的值小于子结点，即根结点的值是最小的，值从小到大排列
    • 关于为什么用小顶堆而不是用大顶堆：
      如果是大顶堆的话，由于仅维护k个元素，每次push进元素时都需要pop掉根结点元素
      而根结点是值最大的元素，这样的话会导致最后大顶堆中都是出现频率最低的前k个元素
      所以要用小顶堆，每次pop元素弹出值最小的元素，维护出现频率最高的前k个元素
    • 小顶堆通过优先级队列实现：其中比较器设置为"左值>右值"（可能与优先级队列的底层实现有关）—— 注意这与快排cmp是相反的，快排cmp“左值>右值"是从大到小降序排列，而优先级队列"左值>右值"是小顶堆（根小子大）
  • 3.找出前K个高频元素，因为小顶堆先弹出的是最小的（取first即元素的键），所以倒序来输出到数组
• 学会小顶堆的实现以及小顶堆遍历的写法：

// 小顶堆实现
class mycomparison {
public:
    bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
        return lhs.second > rhs.second;
    }
};
// 优先级队列定义与遍历
priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
// 参数1：优先级队列的元素类型，参数2：优先级队列自身类型，参数3：优先级队列的比较器（决定是小顶堆还是大顶堆）
for (unordered_map<int, int>::iterator it = cnt.begin(); it != cnt.end(); it++) {
	pri_que.push(*it); // 把it指向的放进队列
    if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
        pri_que.pop();
    }
}