查找给定数组中出现次数最多的 k 个数字

在实际开发中，我们可能会遇到需要查找一个数组中出现次数最多的 k 个数字的情况。解决这个问题的方法有很多，下面我们就来介绍一些常见的方法。

方法一 - 暴力法

暴力法是最简单的解决方法，具体步骤如下：

1. 遍历整个数组，并记录每个元素出现的次数。
2. 对所有元素出现次数进行排序，并返回前 k 个元素。

代码实现如下：

def find_k_max(nums, k):
    counter = {}
    for num in nums:
        if num in counter:
            counter[num] += 1
        else:
            counter[num] = 1
    sorted_nums = sorted(counter.items(), key=lambda x: x[1], reverse=True)
    return [num[0] for num in sorted_nums[:k]]

由于需要对数组中出现的所有元素进行遍历和排序，时间复杂度为 $O(nlogn)$，空间复杂度为 $O(n)$。

方法二 - 堆

堆是一种高效的数据结构，可以用来解决此类问题。我们维护一个大小为 k 的小根堆（即堆顶元素最小），并将数组中的每个元素插入堆中。如果堆元素个数超过了 k，就弹出堆顶元素。最终堆中剩下的元素就是出现次数最多的 k 个数字。

代码实现如下：

import heapq

def find_k_max(nums, k):
    counter = {}
    for num in nums:
        if num in counter:
            counter[num] += 1
        else:
            counter[num] = 1
    heap = []
    for num, count in counter.items():
        if len(heap) < k:
            heapq.heappush(heap, (count, num))
        elif count > heap[0][0]:
            heapq.heappop(heap)
            heapq.heappush(heap, (count, num))
    return [num for _, num in heap]

由于需要遍历整个数组和维护一个大小为 k 的堆，时间复杂度为 $O(nlogk)$，空间复杂度为 $O(n)$。

方法三 - 桶

桶是另一种高效的数据结构，可以用来解决此类问题。我们维护 k 个桶，每个桶存储出现次数相同的数字。遍历一遍数组后，从后往前遍历桶，并将桶中的元素记入结果中。

代码实现如下：

def find_k_max(nums, k):
    counter = {}
    for num in nums:
        if num in counter:
            counter[num] += 1
        else:
            counter[num] = 1
    bucket = [[] for _ in range(len(nums) + 1)]
    for num, count in counter.items():
        bucket[count].append(num)
    result = []
    for i in range(len(nums), 0, -1):
        if bucket[i]:
            result += bucket[i]
            if len(result) >= k:
                break
    return result[:k]

由于需要遍历整个数组和维护 k 个桶，时间复杂度为 $O(n)$，空间复杂度为 $O(n)$。

以上就是三种常见的解决方法，根据实际场景选择不同的方法即可。在时间效率和空间效率上，堆和桶的表现优于暴力法，因为暴力法需要对每个元素进行排序，而堆和桶只需要对出现次数最多的 k 个数字进行排序。