LeetCode 347. 前 K 个高频元素
问题描述
给定一个整数数组 nums
和一个整数 k
,返回数组中前 k
个出现频率最高的元素。答案可以按任意顺序返回。
示例:
输入:nums = [1,1,1,2,2,3], k = 2
输出:[1,2]
输入:nums = [1], k = 1
输出:[1]
算法思路
最小堆(优先队列):
- 统计频率:遍历数组,使用哈希表记录每个数字出现的频率。
- 维护 Top K:
- 使用最小堆(优先队列)存储元素,按频率从小到大排序。
- 遍历哈希表,将元素加入堆中。
- 当堆大小超过
k
时,弹出堆顶元素(当前最小频率元素)。
- 构建结果:将堆中剩余元素按频率从高到低放入结果数组。
代码实现
import java.util.*;
class Solution {
public int[] topKFrequent(int[] nums, int k) {
// 1. 统计频率
Map<Integer, Integer> frequencyMap = new HashMap<>();
for (int num : nums) {
frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
}
// 2. 最小堆维护Top K(按频率从小到大排序)
PriorityQueue<Integer> minHeap = new PriorityQueue<>(
(a, b) -> frequencyMap.get(a) - frequencyMap.get(b)
);
for (int num : frequencyMap.keySet()) {
minHeap.offer(num);
if (minHeap.size() > k) {
minHeap.poll(); // 弹出频率最小的元素
}
}
// 3. 构建结果(从高到低填充)
int[] result = new int[k];
for (int i = k - 1; i >= 0; i--) {
result[i] = minHeap.poll();
}
return result;
}
}
注释
-
频率统计:
- 使用
HashMap
记录每个数字出现的次数。 - 遍历数组
nums
,更新哈希表:frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1)
。
- 使用
-
最小堆维护:
- 初始化:最小堆按频率排序
(a, b) -> frequencyMap.get(a) - frequencyMap.get(b)
。 - 遍历哈希表:
- 将当前数字加入堆中:
minHeap.offer(num)
。 - 堆大小超过
k
时弹出堆顶元素:minHeap.poll()
(保证堆中始终是频率最高的k
个元素)。
- 将当前数字加入堆中:
- 初始化:最小堆按频率排序
-
结果构建:
- 创建大小为
k
的结果数组。 - 倒序填充:从数组末尾开始填充堆中元素(频率从高到低),
result[i] = minHeap.poll()
。
- 创建大小为
算法分析
- 时间复杂度:O(n log k)
- 频率统计:O(n)
- 堆操作:每次插入/弹出 O(log k),最坏情况 n 次操作 → O(n log k)
- 空间复杂度:O(n + k)
- 哈希表 O(n),最小堆 O(k)
算法过程
输入:nums = [1,1,1,2,2,3]
, k = 2
- 统计频率:
1:3
,2:2
,3:1
- 最小堆操作:
- 加入
1
→ 堆[1]
- 加入
2
→ 堆[2,1]
(堆顶2
频率最小) - 加入
3
→ 堆[3,2,1]
,堆大小超过k
,弹出堆顶3
→ 堆[2,1]
- 加入
- 构建结果:
- 倒序填充:
result[1]=2
,result[0]=1
→[1,2]
- 倒序填充:
优化解法(快速选择)
import java.util.*;
class Solution {
public int[] topKFrequent(int[] nums, int k) {
// 统计频率
Map<Integer, Integer> freqMap = new HashMap<>();
for (int num : nums) freqMap.put(num, freqMap.getOrDefault(num, 0) + 1);
// 获取唯一数字数组
int[] uniqueNums = new int[freqMap.size()];
int index = 0;
for (int num : freqMap.keySet()) uniqueNums[index++] = num;
// 快速选择分区
quickSelect(uniqueNums, 0, uniqueNums.length - 1, k, freqMap);
// 返回前k个高频元素
return Arrays.copyOfRange(uniqueNums, 0, k);
}
private void quickSelect(int[] nums, int left, int right, int k,
Map<Integer, Integer> freqMap) {
if (left >= right) return;
// 分区操作
int pivotIndex = partition(nums, left, right, freqMap);
// 根据分区位置递归处理
if (pivotIndex == k) return;
else if (pivotIndex > k) quickSelect(nums, left, pivotIndex - 1, k, freqMap);
else quickSelect(nums, pivotIndex + 1, right, k, freqMap);
}
private int partition(int[] nums, int left, int right,
Map<Integer, Integer> freqMap) {
// 随机选择基准避免最坏情况
int randomIndex = left + (int)(Math.random() * (right - left + 1));
swap(nums, randomIndex, right);
int pivotFreq = freqMap.get(nums[right]);
int storeIndex = left;
// 将高频元素移到数组左侧
for (int i = left; i < right; i++) {
if (freqMap.get(nums[i]) > pivotFreq) {
swap(nums, storeIndex, i);
storeIndex++;
}
}
swap(nums, storeIndex, right);
return storeIndex;
}
private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
测试用例
public static void main(String[] args) {
Solution solution = new Solution();
// 测试用例1:标准示例
int[] nums1 = {1,1,1,2,2,3};
System.out.println("Test1: " + Arrays.toString(solution.topKFrequent(nums1, 2))); // [1,2]
// 测试用例2:单元素
int[] nums2 = {1};
System.out.println("Test2: " + Arrays.toString(solution.topKFrequent(nums2, 1))); // [1]
// 测试用例3:多个相同频率
int[] nums3 = {1,1,2,2,3,3};
System.out.println("Test3: " + Arrays.toString(solution.topKFrequent(nums3, 2))); // [1,2] 或 [2,3] 等
// 测试用例4:K等于数组长度
int[] nums4 = {4,1,-1,2,-1,2,3};
System.out.println("Test4: " + Arrays.toString(solution.topKFrequent(nums4, 3))); // [-1,2,4] 或排列
}
关键点
- 频率统计:
- 哈希表高效记录元素出现次数。
- 最小堆维护 Top K:
- 堆大小不超过
k
,保证时间复杂度 O(n log k)。 - 堆排序规则:按频率升序(堆顶最小)。
- 堆大小不超过
- 结果构建:
- 倒序填充数组实现频率从高到低排列。
- 快速选择优化:
- 时间复杂度优化至平均 O(n),最坏 O(n²)。
- 分区时将高频元素移至左侧。
- 边界处理:
k = 0
或空数组直接返回空集。k
等于唯一元素数量时返回所有元素。