leetcode hot 100

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 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。

思路一：HashMap 计数 + 排序

使用hashmap对每个元素进行出现次数统计

对hashmap根据value进行排序，排序前要先把hashmap中的所有entry都存入到一个list中，只有在list中才可以使用Collections.sort()进行排序

保存前k个元素到数组

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 使用hashmap对每个元素进行出现次数统计
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int num : nums){
            if(map.containsKey(num)){
                map.put(num, map.get(num)+1);
            }else{
                map.put(num, 1);
            }
        }

        // 对hashmap根据value进行排序
        // 先把hashmap中的所有entry都存入到一个list中，只有在list中才可以使用Collections.sort()进行排序
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>();
        list.addAll(map.entrySet());

        Collections.sort(list, new Comparator<Map.Entry<Integer,Integer>>(){
            public int compare(Map.Entry<Integer,Integer> o1, Map.Entry<Integer,Integer> o2){
                return o2.getValue() - o1.getValue();
            }
        });

        // 保存前k个元素到数组
        int[] res = new int[k];
        int i = 0;
        for(Map.Entry<Integer,Integer> en : list){
            res[i++] = en.getKey();
            if(i >= k){
                break;
            }
        }
        return res;
    }
}

leetcode 执行用时：18 ms > 45.17%, 内存消耗：41.1 MB > 93.84%

复杂度分析：

时间复杂度：O(nlogn), 使用Hashmap进行计数的复杂度为O(n), 随后对hashmap进行排序，虽然其中的键值对可能没有n那么多，但是在最坏情况下键值对的个数为n, 所以排序的时间复杂度为O(nlogn)

空间复杂度：O(2n); 需要一个hashMap存储每个值出现的次数，键值对最大为O(n), 随后将所有健值对存入一个临时 list, 也花费了O(n)的空间，所以整体空间复杂度为O(2n)

思路二：HashMap计数 + 堆

这次仍然是先使用HashMap进行计数，然后维持一个大小为k的最小堆，最后取出堆中所有元素存入一个数组

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 使用hashmap对每个元素进行出现次数统计
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int num : nums){
            if(map.containsKey(num)){
                map.put(num, map.get(num)+1);
            }else{
                map.put(num, 1);
            }
        }

        // 然后维持一个大小为k的最小堆
        PriorityQueue<Integer> queue = new PriorityQueue<>((a, b) -> map.get(a) - map.get(b));
        for(Integer key : map.keySet()){
            queue.offer(key);
            if(queue.size() > k){
                queue.poll();
            }
        }

        // 最后取出堆中所有元素存入一个数组
        int[] res = new int[k];
        for(int i = 0; i < k; i++){
            res[i] = queue.poll();
        }
        return res;
    }
}

leetcode 执行用时：18 ms > 45.17%, 内存消耗：41.2 MB > 90.21%

复杂度分析：

时间复杂度: O(nlogk)。hashMap计数的时间是O(n), 后面维持一个大小为k的堆的时间花费为O(nlogk), 所以整体时间复杂度为O(nlogk)。

空间复杂度：O(n+k)。需要一个最大为O(n)的map 和一个 O(k)的堆，所以时间复杂度O(n+k)。

思路二：HashMap计数 + 桶排序

先使用hashmap进行计数，然后创建一个大小为 (n + 1) 的列表 list(之所以是n+1， 因为如果所有元素都是同一个元素的话，那这个元素的出现次数就是n, 那下标就是n, 所以需要一个大小为n+1的列表，这个列表的每个元素被当成是一个桶，每个桶是一个小列表，hashmap的值作为下标，键作为桶里的值，这样这个 list 列表中就保存了每个出现次数的所有元素。最后从大小遍历这个list, 把不为空的子列表元素都加入到数组中

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 使用hashmap对每个元素进行出现次数统计
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int num : nums){
            if(map.containsKey(num)){
                map.put(num, map.get(num)+1);
            }else{
                map.put(num, 1);
            }
        }

        // 然后创建一个大小为 (n + 1) 的列表 list
        // 这个列表的每个元素被当成是一个桶，每个桶是一个小列表，hashmap的值作为下标，键作为桶里的值，
        // 这样这个 list 列表中就保存了每个出现次数的所有元素。
        List<Integer>[] list = new List[nums.length+1];
        for(Map.Entry<Integer, Integer> en : map.entrySet()){
            if(list[en.getValue()]== null){
                list[en.getValue()] = new ArrayList<Integer>();
            }
            list[en.getValue()].add(en.getKey());
        }

        // 最后从大小遍历这个list, 把不为空的子列表元素都加入到数组中

        ArrayList<Integer> res = new ArrayList<>();
        for(int i = nums.length; i >= 0 && res.size() < k; i--){
            if(list[i] != null){
                res.addAll(list[i]);
            }
        }
        int[] arr = new int[k];
        for(int i = 0; i < k; i++){
            arr[i] = res.get(i);
        }
        return arr;
    }
}

leetcode 执行用时：14 ms > 92.28%, 内存消耗：41.3 MB > 72.55%

复杂度分析：

时间复杂度：O(n). 三个for循环，所以时间复杂度为O(n)

空间复杂度：需要一个大小为O(n)的hashmap, 一个大小为O(n+1)的list,数组，和一个大小为O(k)的结果列表，所以时间复杂度为O(2n+k+1), 即O(n)