LeetCode 347. Top K Frequent Elements(java)

Given a non-empty array of integers, return the k most frequent elements.

For example,
Given [1,1,1,2,2,3] and k = 2, return [1,2].

Note:
You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
Your algorithm’s time complexity must be better than O(n log n), where n is the array’s size.

解法：我的解法是用hashmap存，再排序一遍，最后输出前k个，代码如下，时间复杂度为O(n)，空间复杂度为O(n)。

public List<Integer> topKFrequent(int[] nums, int k) {
        List<Integer> result = new ArrayList<>();
        if (nums.length == 0) return result;
        HashMap<Integer,Integer> map = new HashMap<>();
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.put(nums[i], map.get(nums[i]) + 1);
            } else {
                map.put(nums[i], 1);
            }
        }
        List<Map.Entry<Integer,Integer>> list = new ArrayList<>(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();
            }
        });
        for (int i = 0; i < k; i++) {
            result.add(list.get(i).getKey());
        }
        return result;
    }

解法二：时间复杂度为O(max(n, range))，空间复杂度为O(max(n, range))，其中range为数组中数的范围大小，range = max - min。基本思想就是bucket sort，这道题实际上就是桶排序的代码，并且是适用于有重复元素的桶排序，只是这里排序的数字是频率而不是数字本身的大小。所以，首先我们需要一个数组放下各个数字出现的频率，得到这个频率数组以后，直接用桶排序的代码就可以了。

public List<Integer> topKFrequent(int[] nums, int k) {
        List<Integer> result = new ArrayList<>();
        if (nums.length == 0) return result;
        int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
        //先traverse一遍找到最小和最大值，来确定bucket的长度
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] < min) min = nums[i];
            if (nums[i] > max) max = nums[i];
        }
        //traverse数组，每个value计数并放进data数组里
        int[] data = new int[max - min + 1];
        for (int i = 0; i < nums.length; i++) {
            data[nums[i] - min]++;
        }
        //创建一个list数组，把data里的value作为下标，把答案放进bucket里
        List[] bucket = new List[nums.length + 1];
        for (int i = 0; i < data.length; i++) {
            if (data[i] > 0) {
                if (bucket[data[i]] == null) {
                    bucket[data[i]] = new ArrayList<Integer>();
                }
                List<Integer> list = bucket[data[i]];
                list.add(i + min);
                bucket[data[i]] = list;
            }
        }
        //输出答案
        int j = 0;
        for (int i = nums.length; i >= 0 && result.size() < k; i--) {
            if (bucket[i] != null) result.addAll(bucket[i]);
        }
        return result;
    }