LeetCode 算法：前 K 个高频元素 c++

原题链接🔗：前 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 <= 10⁵
• k 的取值范围是 [1, 数组中不相同的元素的个数]
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

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

堆

• 堆（Heap）是一种特殊的树状数据结构，它满足两个主要特性：

  1. 结构性：堆通常是一棵完全二叉树，这意味着除了最后一层外，其他每一层都被完全填满，并且最后一层的节点尽可能地集中在左侧。

  2. 堆属性：堆中的每一个节点都必须满足特定的顺序要求，这个要求可以是最大堆属性或最小堆属性。

     • 最大堆：任何一个父节点的值都大于或等于它的子节点的值。这意味着堆的根节点是所有节点中的最大值。
     • 最小堆：任何一个父节点的值都小于或等于它的子节点的值。这意味着堆的根节点是所有节点中的最小值。

• 堆在计算机科学中广泛应用于各种算法和数据结构，特别是在需要快速访问最大元素或最小元素的场景中。例如，堆排序算法、优先队列的实现等。

• 在编程语言中，堆通常通过优先队列（Priority Queue）这种抽象数据类型来实现。优先队列允许快速地插入新元素和删除（或检索）最大（或最小）元素。

• 堆的常见操作包括：

  • 插入（Push）：向堆中添加一个新元素。
  • 删除最大/最小元素（Pop）：移除并返回堆中的最大（或最小）元素。
  • 查找最大/最小元素（Peek/Top）：返回堆中的最大（或最小）元素，但不从堆中移除它。

• 堆的实现可以通过数组来完成，其中每个元素的索引和其父节点或子节点的索引之间有一定的数学关系。例如，在数组表示的堆中，一个元素的父节点可以通过(i-1)/2计算得到，其中i是该元素的索引；其子节点可以通过2*i + 1（左子节点）和2*i + 2（右子节点）计算得到。

题解

1. 解题思路：

"数组中的第K个最大元素"是LeetCode上的一道经典题目，它要求在给定的未排序数组中找到第K个最大的元素。以下是解题的几种思路：

1. 排序

• 思路：首先对数组进行排序，然后直接访问数组的倒数第K个位置的元素。
• 复杂度：时间复杂度为O(n log n)，空间复杂度为O(1)（如果使用原地排序算法）。

2. 快速选择（Quick Select）

• 思路：这是快速排序算法的变种。选择一个"枢纽"（pivot）元素，将数组分为两部分：一部分包含比枢纽小的元素，另一部分包含比枢纽大的元素。然后根据枢纽的位置来决定是继续在左侧还是右侧搜索第K个最大元素。
• 复杂度：平均时间复杂度为O(n)，最坏情况（已排序数组）为O(n^2)。

3. 堆（优先队列）

• 思路：
  • 使用最小堆：维护一个大小为K的最小堆，遍历数组，对于每个元素，如果堆未满，则直接加入；如果堆满了且当前元素大于堆顶元素，则替换堆顶元素。
  • 使用最大堆：维护一个大小为n的堆，遍历数组，对于每个元素，如果堆未满，则直接加入；如果堆满了且当前元素小于堆顶元素，则不加入。最后，堆顶元素是第K大的元素，但这种方法需要O(n)空间。
• 复杂度：时间复杂度为O(n log K)，空间复杂度为O(K)。

4. BFPRT算法（中位数的中位数算法）

• 思路：这是一种选择算法，用于找到未排序数组的第K小（或第K大）元素。它首先找到一组“候选”元素，然后递归地在这组候选元素中找到中位数，直到找到第K小的元素。
• 复杂度：平均时间复杂度为O(n)。

5. 线性时间选择算法

• 思路：这是一种基于随机化的算法，通过随机选择枢纽元素来减少最坏情况的发生概率。
• 复杂度：期望时间复杂度为O(n)。

2. c++ demo：

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>

// 自定义比较函数，首先按频率降序，频率相同则按元素值升序
bool compare(const std::pair<int, int>& a, const std::pair<int, int>& b) {
    if (a.second == b.second) {
        return a.first < b.first;
    }
    return a.second > b.second;
}

std::vector<int> topKFrequent(const std::vector<int>& nums, int k) {
    std::unordered_map<int, int> freqMap;
    for (int num : nums) {
        freqMap[num]++;
    }

    std::vector<std::pair<int, int>> freqList;
    for (const auto& kv : freqMap) {
        freqList.emplace_back(kv.first, kv.second);
    }

    // 根据频率和元素值排序
    std::sort(freqList.begin(), freqList.end(), compare);

    // 选择前 K 个元素
    std::vector<int> result;
    for (int i = 0; i < k; ++i) {
        result.push_back(freqList[i].first);
    }
    return result;
}

int main() {
    std::vector<int> nums = { 1, 1, 1, 2, 2, 3 };
    int k = 2;
    std::vector<int> result = topKFrequent(nums, k);

    std::cout << "The " << k << " most frequent elements are: ";
    for (int num : result) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

• 输出结果：

The 2 most frequent elements are: 1 2

3. 代码仓库地址：topKFrequent