leetcode-347-前K个高频元素(top k frequent elements)-java-优快云博客

本文链接：https://blog.youkuaiyun.com/xushiyu1996818/article/details/84644584

题目及测试

package pid374;
/* 前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 是数组的大小。


*/

import java.util.List;

public class main {
	
	public static void main(String[] args) {
		int[][] testTable = {{1,1,1,2,2,3},{1}};
		int[] testTable2={2,1};
		for (int i=0;i<testTable.length;i++) {
			test(testTable[i],testTable2[i]);
		}
	}
		 
	private static void test(int[] ito,int ito2) {
		List<Integer> rtn;
		Solution solution=new Solution();
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ito.length; i++) {
		    System.out.print(ito[i]+" ");		    
		}
		System.out.println();
		//开始时打印数组
		System.out.println("ito2="+ito2);
		rtn = solution.topKFrequent(ito,ito2);//执行程序
		long end = System.currentTimeMillis();	
		
		System.out.println(ito + ": rtn=" );
		System.out.println( " rtn=" );
		for (int i = 0; i < rtn.size(); i++) {
		    System.out.print(rtn.get(i)+" ");
		}//打印结果几数组
		
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，22ms，很快）

其实该提就是对map的value进行排序，方法

    List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());  
    Collections.sort(list, new Comparator<Entry<Integer, Integer>>() {
        @Override
        public int compare(Entry<Integer, Integer> o1,
                Entry<Integer, Integer> o2) {
                if(o2.getValue().compareTo(o1.getValue())>0){  
                    return 1;  
               }else if(o2.getValue().compareTo(o1.getValue())<0){  
                    return -1;  
               }  else {
                   return 0;
               }
        }

先建立map，key为int[i]，value为该值得次数，然后将map化为set，化为list，用collections。Sort对list排序，然后取出前k个的key即可

package pid374;

import java.lang.reflect.Array;
import java.util.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

class Solution {
public List<Integer> topKFrequent(int[] nums, int k) {
    HashMap<Integer, Integer> map=new HashMap<>();
    List<Integer> result=new ArrayList<>();
    int length=nums.length;
    for(int i=0;i<length;i++){
    	int now=nums[i];
    	if(map.containsKey(now)){
    		map.put(now, map.get(now)+1);
    	}
    	else{
    		map.put(now,1);
    	}
    }
    List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());  
    Collections.sort(list, new Comparator<Entry<Integer, Integer>>() {
        @Override
        public int compare(Entry<Integer, Integer> o1,
                Entry<Integer, Integer> o2) {
                if(o2.getValue().compareTo(o1.getValue())>0){  
                    return 1;  
               }else if(o2.getValue().compareTo(o1.getValue())<0){  
                    return -1;  
               }  else {
                   return 0;
               }
        }
                  
    });
    for(int i=0;i<k;i++){
    	result.add(list.get(i).getKey());
    }
	return result;
    }
}

解法2（成功，22ms，较快）

对value，放入treemap中排序，

	public List<Integer> topKFrequent(int[] nums, int k) {
		List<Integer> result=new ArrayList<>();
		int length=nums.length;
		if(length==0||k==0){
			return result;
		}
		// key为数字，value为数字出现的个数
		HashMap<Integer, Integer> map=new HashMap<>();
		for(int i=0;i<length;i++){
			int now=nums[i];
			if(map.containsKey(now)){
				map.put(now, map.get(now)+1);
			}else{
				map.put(now, 1);
			}
		}
		// key为数字出现的个数，value为数字
		TreeMap<Integer, List<Integer>> treeMap=new TreeMap<>();
		for(Integer now:map.keySet()){
			Integer num=map.get(now);
			if(treeMap.containsKey(num)){
				List<Integer> list=treeMap.get(num);
				list.add(now);
			}else{
				List<Integer> list=new ArrayList<>();
				list.add(now);
				treeMap.put(num, list);
			}
		}
		for(Integer num:treeMap.descendingMap().keySet()){
			List<Integer> list=treeMap.get(num);
			for(int i=0;i<list.size();i++){
				result.add(list.get(i));
				k--;
				if(k==0){
					return result;
				}
			}
		}		
		return result;
	}

解法3（别人的）

最小堆，对values，使用最小堆排序，对于 k 频率之后的元素不用再去处理，进一步优化时间复杂度。

借助哈希表来建立数字和其出现次数的映射，遍历一遍数组统计元素的频率
维护一个元素数目为 k的最小堆
每次都将新的元素与堆顶元素（堆中频率最小的元素）进行比较
如果新的元素的频率比堆顶端的元素大，则弹出堆顶端的元素，将新的元素添加进堆中
最终，堆中的 k个元素即为前 k个高频元素



class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        // 使用字典，统计每个元素出现的次数，元素为键，元素出现的次数为值
        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);
             }
        }
        // 遍历map，用最小堆保存频率最大的k个元素
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return map.get(a) - map.get(b);
            }
        });
        for (Integer key : map.keySet()) {
            if (pq.size() < k) {
                pq.add(key);
            } else if (map.get(key) > map.get(pq.peek())) {
                pq.remove();
                pq.add(key);
            }
        }
        // 取出最小堆中的元素
        List<Integer> res = new ArrayList<>();
        while (!pq.isEmpty()) {
            res.add(pq.remove());
        }
        return res;
    }
}

解法4（别人的）

对values计数排序



//基于桶排序求解「前 K 个高频元素」
class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        List<Integer> res = new ArrayList();
        // 使用字典，统计每个元素出现的次数，元素为键，元素出现的次数为值
        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);
             }
        }
        
        //桶排序
        //将频率作为数组下标，对于出现频率不同的数字集合，存入对应的数组下标
        List<Integer>[] list = new List[nums.length+1];
        for(int key : map.keySet()){
            // 获取出现的次数作为下标
            int i = map.get(key);
            if(list[i] == null){
               list[i] = new ArrayList();
            } 
            list[i].add(key);
        }
        
        // 倒序遍历数组获取出现顺序从大到小的排列
        for(int i = list.length - 1;i >= 0 && res.size() < k;i--){
            if(list[i] == null) continue;
            res.addAll(list[i]);
        }
        return res;
    }
}