leetcode hot 100 - 347. 前 K 个高频元素
作者：互联网
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个元素到数组
1 class Solution {
2 public int[] topKFrequent(int[] nums, int k) {
3 // 使用hashmap对每个元素进行出现次数统计
4 HashMap<Integer, Integer> map = new HashMap<>();
5 for(int num : nums){
6 if(map.containsKey(num)){
7 map.put(num, map.get(num)+1);
8 }else{
9 map.put(num, 1);
10 }
11 }
12
13 // 对hashmap根据value进行排序
14 // 先把hashmap中的所有entry都存入到一个list中，只有在list中才可以使用Collections.sort()进行排序
15 List<Map.Entry<Integer, Integer>> list = new ArrayList<>();
16 list.addAll(map.entrySet());
17
18 Collections.sort(list, new Comparator<Map.Entry<Integer,Integer>>(){
19 public int compare(Map.Entry<Integer,Integer> o1, Map.Entry<Integer,Integer> o2){
20 return o2.getValue() - o1.getValue();
21 }
22 });
23
24 // 保存前k个元素到数组
25 int[] res = new int[k];
26 int i = 0;
27 for(Map.Entry<Integer,Integer> en : list){
28 res[i++] = en.getKey();
29 if(i >= k){
30 break;
31 }
32 }
33 return res;
34 }
35 }
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的最小堆，最后取出堆中所有元素存入一个数组
1 class Solution {
2 public int[] topKFrequent(int[] nums, int k) {
3 // 使用hashmap对每个元素进行出现次数统计
4 HashMap<Integer, Integer> map = new HashMap<>();
5 for(int num : nums){
6 if(map.containsKey(num)){
7 map.put(num, map.get(num)+1);
8 }else{
9 map.put(num, 1);
10 }
11 }
12
13 // 然后维持一个大小为k的最小堆
14 PriorityQueue<Integer> queue = new PriorityQueue<>((a, b) -> map.get(a) - map.get(b));
15 for(Integer key : map.keySet()){
16 queue.offer(key);
17 if(queue.size() > k){
18 queue.poll();
19 }
20 }
21
22 // 最后取出堆中所有元素存入一个数组
23 int[] res = new int[k];
24 for(int i = 0; i < k; i++){
25 res[i] = queue.poll();
26 }
27 return res;
28 }
29 }
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, 把不为空的子列表元素都加入到数组中
1 class Solution {
2 public int[] topKFrequent(int[] nums, int k) {
3 // 使用hashmap对每个元素进行出现次数统计
4 HashMap<Integer, Integer> map = new HashMap<>();
5 for(int num : nums){
6 if(map.containsKey(num)){
7 map.put(num, map.get(num)+1);
8 }else{
9 map.put(num, 1);
10 }
11 }
12
13 // 然后创建一个大小为 (n + 1) 的列表 list
14 // 这个列表的每个元素被当成是一个桶，每个桶是一个小列表，hashmap的值作为下标，键作为桶里的值，
15 // 这样这个 list 列表中就保存了每个出现次数的所有元素。
16 List<Integer>[] list = new List[nums.length+1];
17 for(Map.Entry<Integer, Integer> en : map.entrySet()){
18 if(list[en.getValue()]== null){
19 list[en.getValue()] = new ArrayList<Integer>();
20 }
21 list[en.getValue()].add(en.getKey());
22 }
23
24 // 最后从大小遍历这个list, 把不为空的子列表元素都加入到数组中
25
26 ArrayList<Integer> res = new ArrayList<>();
27 for(int i = nums.length; i >= 0 && res.size() < k; i--){
28 if(list[i] != null){
29 res.addAll(list[i]);
30 }
31 }
32 int[] arr = new int[k];
33 for(int i = 0; i < k; i++){
34 arr[i] = res.get(i);
35 }
36 return arr;
37 }
38 }
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)标签：map,num,hashmap,int,复杂度,list,hot,347,100 来源： https://blog.51cto.com/u_14201949/2825893