算法题 前 K 个高频元素

LeetCode 347. 前 K 个高频元素

问题描述

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

示例

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

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

算法思路

最小堆(优先队列)

  1. 统计频率:遍历数组,使用哈希表记录每个数字出现的频率。
  2. 维护 Top K
    • 使用最小堆(优先队列)存储元素,按频率从小到大排序。
    • 遍历哈希表,将元素加入堆中。
    • 当堆大小超过 k 时,弹出堆顶元素(当前最小频率元素)。
  3. 构建结果:将堆中剩余元素按频率从高到低放入结果数组。

代码实现

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;
    }
}

注释

  1. 频率统计

    • 使用 HashMap 记录每个数字出现的次数。
    • 遍历数组 nums,更新哈希表:frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1)
  2. 最小堆维护

    • 初始化:最小堆按频率排序 (a, b) -> frequencyMap.get(a) - frequencyMap.get(b)
    • 遍历哈希表
      • 将当前数字加入堆中:minHeap.offer(num)
      • 堆大小超过 k 时弹出堆顶元素:minHeap.poll()(保证堆中始终是频率最高的 k 个元素)。
  3. 结果构建

    • 创建大小为 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. 统计频率
    • 1:3, 2:2, 3:1
  2. 最小堆操作
    • 加入 1 → 堆 [1]
    • 加入 2 → 堆 [2,1](堆顶 2 频率最小)
    • 加入 3 → 堆 [3,2,1],堆大小超过 k,弹出堆顶 3 → 堆 [2,1]
  3. 构建结果
    • 倒序填充: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] 或排列
}

关键点

  1. 频率统计
    • 哈希表高效记录元素出现次数。
  2. 最小堆维护 Top K
    • 堆大小不超过 k,保证时间复杂度 O(n log k)。
    • 堆排序规则:按频率升序(堆顶最小)。
  3. 结果构建
    • 倒序填充数组实现频率从高到低排列。
  4. 快速选择优化
    • 时间复杂度优化至平均 O(n),最坏 O(n²)。
    • 分区时将高频元素移至左侧。
  5. 边界处理
    • k = 0 或空数组直接返回空集。
    • k 等于唯一元素数量时返回所有元素。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值