[LeetCode 中等]347. 前 K 个高频元素

题目描述

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

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

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

提示：

你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/top-k-frequent-elements
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

priorityQueue

class Solution {
        public static int[] topKFrequent(int[] nums, int k) {
            Map<Integer, Integer> map = new HashMap<>();
            for(int num:nums){
                map.put(num,map.getOrDefault(num,0)+1);
            }

            PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(new Comparator<int[]>(){
                public int compare(int[] a, int[] b){
                    return a[1]-b[1];
                }
            });

            for(Map.Entry<Integer,Integer> pair:map.entrySet() ){
            // int[] 的第一个元素代表数组的值，第二个元素代表了该值出现的次数
                int num = pair.getKey();
                int occur = pair.getValue();
                if(priorityQueue.size() == k){
                    if(occur>priorityQueue.peek()[1]){
                        priorityQueue.poll();
                        priorityQueue.offer(new int[]{num,occur});
                    }
                }else{
                    priorityQueue.offer(new int[]{num,occur});
                }
            }


            int[] results = new int[k];
            for (int i = k-1; i >= 0; i--) {
                results[i] = priorityQueue.poll()[0];
                // System.out.println(results[i]);

            }
            return results;
    }
}

快速排序

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> occurrences = new HashMap<Integer, Integer>();
        for (int num : nums) {
            occurrences.put(num, occurrences.getOrDefault(num, 0) + 1);
        }

        List<int[]> values = new ArrayList<int[]>();
        // 依旧是取出每一个key value对
        for (Map.Entry<Integer, Integer> entry : occurrences.entrySet()) {
            int num = entry.getKey(), count = entry.getValue();
            values.add(new int[]{num, count});
        }
        int[] results = new int[k];
        qsort(values, 0, values.size() - 1, results, 0, k);
        return results;
    }
// start 和 end是qsort的范围
//addIndex 是在答案的数组中，后面循环产生的答案 从哪个位置开始添加
    public void qsort(List<int[]> values, int start, int end, int[] results, int addIndex, int k) {
        // 随机产生一个pivot
        int picked = (int) (Math.random() * (end - start + 1)) + start;
        Collections.swap(values, picked, start);
        // 从开头开始循环 发现比pivot大的数字 就把它和pivot后面的数字进行交换
        // index表示的是 pivot最后的位置 也就是有多少个数字比pivot大
        int pivot = values.get(start)[1];
        int index = start;
        for (int i = start + 1; i <= end; i++) {
            if (values.get(i)[1] >= pivot) {
                Collections.swap(values, index + 1, i);
                index++;
            }
        }
        Collections.swap(values, start, index);
        // 如果有index-srart个数字比pivot大 k小于这个数 说明前面的还需要再排列
        if (k <= index - start) {
            qsort(values, start, index - 1, results, addIndex, k);
        } else {
        // 如果有index-srart个数字比pivot大 k大于这个数 说明前面的不需要再排列  
        // 直接放进结果的数组里 需要吧后面比pivot小的在进行一次排序
            for (int i = start; i <= index; i++) {
                results[addIndex++] = values.get(i)[0];
            }
            if (k > index - start + 1) {
                qsort(values, index + 1, end, results, addIndex, k - (index - start + 1));
            }
        }
    }
}