LeetCode Top 100 Liked Questions 347. Top K Frequent Elements (Java版； Medium)

welcome to my blog

LeetCode Top 100 Liked Questions 347. Top K Frequent Elements (Java版; Medium)

题目描述

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

Example 1:

Input: nums = [1,1,1,2,2,3], k = 2
Output: [1,2]
Example 2:

Input: nums = [1], k = 1
Output: [1]
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.

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        int n = nums.length;
        if(n==0){
            return new int[]{};
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int a : nums){
            map.put(a, map.getOrDefault(a, 0)+1);
        }
        PriorityQueue<Map.Entry<Integer, Integer>> heap = new PriorityQueue<>((a,b)->a.getValue()-b.getValue());
        for(Map.Entry<Integer, Integer> entry : map.entrySet()){
            if(heap.size()<k){
                heap.add(entry);
            }else if(entry.getValue()>heap.peek().getValue()){
                heap.add(entry);
                heap.poll();
            }
        }
        int[] res = new int[k];
        int i = 0;
        while(!heap.isEmpty()){
            res[i++] = heap.poll().getKey();
        }
        return res;

    }
}

第一次做; 使用桶排序;2个核心:1)桶的大小是数组元素个数加一 2)桶的索引i表示出现i次的元素构成的List; 细节: new List后面不能加<>

/*
桶排序
*/
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;

//k is always valid
class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        /*
        核心:
        1.桶的大小是数组元素个数加一
        2.索引i表示元素出现的次数, value是出现i次的所有元素构成的list
        */
        // 细节1: new List后面不能加<>, 否则报错!
        List<Integer>[] bucket = new List[nums.length+1];
        HashMap<Integer,Integer> map = new HashMap<>();
        //统计各个元素出现的次数
        for(int a : nums){
            if(!map.containsKey(a))
                map.put(a,0);
            map.put(a,map.get(a)+1);
        }
        //遍历哈希表, 装桶
        for(Map.Entry<Integer, Integer>e : map.entrySet()){
            //key是元素的具体值
            Integer key = e.getKey();
            //value是元素的出现次数
            Integer value = e.getValue();
            if(bucket[value]==null)
                bucket[value]=new ArrayList<Integer>();
            bucket[value].add(key);
        }
        //获取结果
        List<Integer> res = new ArrayList<>();
        for(int i=bucket.length-1; i>=0 && res.size()<k; i--){
            if(bucket[i]==null)
                continue;
            res.addAll(bucket[i]);
        }
        return res;
    }
}

第一次做; 使用大小为k的小根堆, 核心: 堆顶元素出现的次数是k个出现次数最多的元素中出现次数最少的那个; 3个细节:1)小根堆存储的是哈希表的键 2)new Comparator<>(){}中可以使用hm 3)遍历哈希表的两种方式hm.entrySet(), hm.keySet()

• 时间复杂度O(NlogK), 注意不是O(NlogN)
• 空间复杂度O(N)

/*
我的第一想法是使用大根堆, 最后弹出k个元素, 不过这样做稍微费空间, 可以建立大小为k的小根堆, 这样就不会存储多余的元素了
当小根堆size超过k时, 当前元素的次数和小根堆堆顶元素的出现次数比较, 如果当前元素出现的次数少, 则遍历下一个元素; 如果当前元素出现的次数多, 则弹出堆顶元素, 将当前元素加入小根堆
核心: 使用小根堆的目的是方便找出当前k个出现次数最多的元素中出现次数最少的元素
*/
import java.util.PriorityQueue;
import java.util.HashMap;
import java.util.Comparator;
import java.util.Map;
import java.util.ArrayList;

//k is always valid
class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        HashMap<Integer,Integer> hm = new HashMap<>();
        //细节1:小根堆存储的是哈希表的键
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(new Comparator<Integer>(){
            /*
            1.细节2:在这里竟然可以使用hm!
            */
            public int compare(Integer o1, Integer o2){
                return hm.get(o1) - hm.get(o2);
            }
        });
        //统计各个元素出现的次数
        for(int a : nums){
            if(!hm.containsKey(a))
                hm.put(a,0);
            hm.put(a, hm.get(a)+1);
        }
        //创建小根堆
        //细节3: 注意如何遍历哈希表
        //也可以用for(Integer k : hm.hm.keySet())
        for(Map.Entry<Integer, Integer> e : hm.entrySet()){
            if(minHeap.size()<k)
                minHeap.add(e.getKey());
            else if(e.getValue() > hm.get(minHeap.peek())){
                minHeap.poll();
                minHeap.add(e.getKey());
            }
        }
        //获取最终的结果
        ArrayList<Integer> res = new ArrayList<>();
        while(!minHeap.isEmpty()){
            res.add(minHeap.poll());
        }
        return res;
    }
}

LeetCode题解; 最优解; 语法细节:frequencyMap.getOrDefault(n, 0); frequencyMap.keySet()

public List<Integer> topKFrequent(int[] nums, int k) {

	List<Integer>[] bucket = new List[nums.length + 1];
	Map<Integer, Integer> frequencyMap = new HashMap<Integer, Integer>();

	for (int n : nums) {
		frequencyMap.put(n, frequencyMap.getOrDefault(n, 0) + 1);
	}

	for (int key : frequencyMap.keySet()) {
		int frequency = frequencyMap.get(key);
		if (bucket[frequency] == null) {
			bucket[frequency] = new ArrayList<>();
		}
		bucket[frequency].add(key);
	}

	List<Integer> res = new ArrayList<>();

	for (int pos = bucket.length - 1; pos >= 0 && res.size() < k; pos--) {
		if (bucket[pos] != null) {
			res.addAll(bucket[pos]);
		}
	}
	return res;
}