LeetCode 347. Top K Frequent Elements

原题链接在这里：https://leetcode.com/problems/top-k-frequent-elements/

题目：

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.

题解：

先计算出element 和对应的frequency.

然后使用bucket sort. 把element按照出现频率放在bucket中.

因为一共只有n 个元素, 那么最大的频率只能是n. n = nums.length. 所以bucket的大小是n+1, 才能对应最大频率.

然后从bucket后扫到前，因为后面的elements 频率高. 加到res中直到res的size到达k.

Note: bucket的生成等号右边是ArrayList[] 而不能是ArrayList<Integer>[], 因为complier 不能判准加进ArrayList中的type, 只有run time才能知道. 所以这里complier不允许确定type.

Time Complexity: O(n), n = nums.length.

Space: O(n).

AC Java:

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

        ArrayList<Integer>[] buckets = new ArrayList[nums.length + 1];
        for(int i = 0; i < buckets.length; i++){
            buckets[i] = new ArrayList<Integer>();
        }
        
        for(Map.Entry<Integer, Integer> entry : hm.entrySet()){
            int key = entry.getKey();
            int freq = entry.getValue();
            buckets[freq].add(key);
        }

        List<Integer> res = new ArrayList<>();
        outerloop:
        for(int i = buckets.length - 1; i >= 0; i--){
            for(int can : buckets[i]){
                res.add(can);
                if(res.size() == k){
                    break outerloop;
                }
            }
        }

        int[] resArr = new int[k];
        for(int i = 0; i < k; i++){
            resArr[i] = res.get(i);
        }

        return resArr;
    }
}

AC C++:

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        vector<int> res;
        if(nums.size() == 0 || k <= 0){
            return res;
        }

        unordered_map<int, int> map;
        for(int num : nums){
            map[num]++;
        }

        vector<vector<int>> buckets(nums.size() + 1);
        for(auto [k, v] : map){
            buckets[v].push_back(k);
        }

        for(int i = buckets.size() - 1; i >= 0; i--){
            for(int can : buckets[i]){
                res.push_back(can);
                if(res.size() == k){
                    return res;
                }
            }
        }

        return res;
    }
};

AC Python:

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        res = []
        n = len(nums)
        map = Counter(nums)
        buckets = [[] for _ in range(n + 1)]
        for key, val in map.items():
            buckets[val].append(key)
        
        for i in range(n, -1, -1):
            for num in buckets[i]:
                res.append(num)
                if len(res) == k:
                    return res
        
        return res

类似Sort Characters By Frequency, Top K Frequent Words, K Closest Points to Origin, Sort Array by Increasing Frequency.