LeetCode hot 100—前 K 个高频元素-优快云博客

题目

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

示例

示例 1:

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

示例 2:

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

分析

要找出整数数组 nums 中出现频率前 k 高的元素，可以采用以下步骤实现：

统计数组中每个元素的出现频率。
根据元素的频率进行排序。
选取前 k 个频率最高的元素。

哈希表+优先队列

统计元素频率：

使用 unordered_map 类型的 frequencyMap 来统计数组中每个元素的出现频率。遍历数组 nums，将元素作为键，出现次数作为值存储在 frequencyMap 中。

使用最小堆维护前 k 个高频元素：

定义一个最小堆 minHeap，其元素类型为 std::pair<int, int>，其中第一个元素表示频率，第二个元素表示对应的数字。使用 std::greater<std::pair<int, int>> 作为比较函数，确保堆顶元素是频率最小的元素。

遍历 frequencyMap，将每个元素及其频率插入到最小堆中。如果堆的大小超过 k，则弹出堆顶元素，保证堆中始终存储频率前 k 高的元素。

提取结果：

遍历最小堆，将堆中的元素依次存入结果数组 result 中。由于堆是按频率从小到大排序的，最后得到的 result 数组即为前 k 个高频元素。

时间复杂度：O( $n\log k$ )， $n$ 是数组的长度，每次插入和删除堆元素的时间复杂度为 O( $\log k$ )

空间复杂度：O( $n$ )，主要用于存储元素频率的哈希表

class Solution {
public:
    std::vector<int> topKFrequent(std::vector<int>& nums, int k) {
        // 统计每个元素的出现频率
        std::unordered_map<int, int> frequencyMap;
        for (int num : nums) {
            frequencyMap[num]++;
        }
        // 定义一个最小堆，存储元素及其频率
        std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<std::pair<int, int>>> minHeap;
        // 遍历频率哈希表
        for (const auto& entry : frequencyMap) {
            minHeap.push({entry.second, entry.first});
            // 如果堆的大小超过 k，弹出堆顶元素
            if (minHeap.size() > k) {
                minHeap.pop();
            }
        }
        // 将堆中的元素存入结果数组
        std::vector<int> result;
        while (!minHeap.empty()) {
            result.push_back(minHeap.top().second);
            minHeap.pop();
        }
        return result;
    }
};

知识充电

堆

堆是一种特殊的完全二叉树，可分为最大堆和最小堆：

最大堆：每个节点的值都大于或等于其子节点的值，即根节点的值是整棵树中的最大值。
最小堆：每个节点的值都小于或等于其子节点的值，即根节点的值是整棵树中的最小值。

完全二叉树是指除了最后一层外，每一层都被完全填充，并且最后一层的节点都尽可能靠左排列。

复杂度分析

插入操作：时间复杂度为 O( $\log n$ )，其中 $n$ 是堆中元素的数量。因为插入元素后，可能需要通过上浮操作将元素调整到合适的位置，而堆的高度为 O( $\log n$ )。
删除堆顶元素操作：时间复杂度为 O( $\log n$ )。删除堆顶元素后，需要将最后一个元素移到堆顶，然后通过下沉操作将其调整到合适的位置。
获取堆顶元素操作：时间复杂度为 O(1)，因为只需要返回堆顶元素的值，不需要进行调整。

C++ 中的堆实现

在 C++ 里，可以使用标准库中的 std::priority_queue 来实现堆。std::priority_queue 是一个容器适配器，它默认实现的是最大堆，但也能通过传入自定义的比较函数来实现最小堆。

#include <iostream>
#include <queue>
#include <vector>

int main() {
    // 创建一个最大堆
    std::priority_queue<int> maxHeap;
    // 插入元素
    maxHeap.push(3);
    maxHeap.push(1);
    maxHeap.push(4);
    maxHeap.push(1);
    maxHeap.push(5);
    maxHeap.push(9);
    // 获取堆顶元素并删除
    while (!maxHeap.empty()) {
        std::cout << maxHeap.top() << " ";
        maxHeap.pop();
    }
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <queue>
#include <vector>

int main() {
    // 创建一个最小堆
    std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;
    // 插入元素
    minHeap.push(3);
    minHeap.push(1);
    minHeap.push(4);
    minHeap.push(1);
    minHeap.push(5);
    minHeap.push(9);
    // 获取堆顶元素并删除
    while (!minHeap.empty()) {
        std::cout << minHeap.top() << " ";
        minHeap.pop();
    }
    std::cout << std::endl;
    return 0;
}