Top K Frequent Elements 选出数组中出现次数最多的k个元素

原题地址：https://leetcode.com/problems/top-k-frequent-elements/，这个题目要求时间复杂度不能超过O(nlgn)，也就是说常规的排序算法不可行（排序算法复杂度至少为nlgn）。那么想到的一种算法是使用优先队列，限制优先队列的大小为K，那么可以做到时间复杂度为O(nlgk)，还能不能再提高呢，另一种方法是使用桶排序，算法复杂度为O(n)。

方法1：使用优先队列，首先要做的统计每个数字出现的次数，这个统计放在一个HashMap中，然后用PriorityQueue来找出结果，因为在PriorityQueue中要借助HashMap来实现排序（将key按照value升序排序），所以在PriorityQueue的构造函数中要把Map当参数传递进去。

代码为：

	//返回一个数组中，出现次数最多的k个数  
    public List<Integer> topKFrequent2(int[] nums, int k) {
    
    	//先统计每个数字出现的次数，这个貌似不可避免，时间复杂度为O(n)
    	HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
    	for(int i=0;i<nums.length;i++){
    		Integer count = map.get(nums[i]);
    		if(count==null){
    			count = 0;
    		}
    		map.put(nums[i], count+1);
    	}
    	
    	//然后应该可以使用优先队列了，
    	PriorityQueue<Integer> pq = new PriorityQueue<Integer>(k,new Comp(map));
    	
    	for(int key:map.keySet()){
    		if(pq.size()<k){
    			pq.add(key);
    			continue;
    		}
    		
    		int small = pq.peek();
    		if(map.get(small)<map.get(key)){
    			pq.poll();
    			pq.add(key);
    		}
    	}
    	return new ArrayList<Integer>(pq);
    }
    
    //注意构造函数，使用map来初始化
    class Comp implements Comparator<Integer>{

    	HashMap<Integer,Integer> map;
    	public Comp(HashMap<Integer,Integer> map){
    		this.map = map;
    	}
    	 
		@Override  //通过key的value来排序
		public int compare(Integer o1, Integer o2) {
			return map.get(o1)-map.get(o2);
		}
    	
    }

方法二：

桶排序的时间复杂度为O(n)，空间复杂度也是O(n)，这个桶排序实际上是将统计数字出现次数的Map逆转一下

代码：

     * 求一个数组中，出现次数最多的k个数，利用桶排序的思想，注意这里的桶排序空间
     * 复杂度为O(n)，桶的下标表示出现的次数，桶的元素是一个List，表示所有出现了
     * 这些次数的元素，厉害
     * */
    public List<Integer> topKFrequent(int[] nums, int k) {
    	
    	//第一步，还是先统计每个数字出现的次数，这个貌似不可避免，时间复杂度为O(n)
    	HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
    	for(int i=0;i<nums.length;i++){
    		Integer count = map.get(nums[i]);
    		if(count==null){
    			count = 0;
    		}
    		map.put(nums[i], count+1);
    	}
    	
    	//第二步，构造一个桶，下标表示出现次数，如果nums大小为n，且这n个数相等，那么
    	//出现次数最大为n，所有桶的大小为n+1
    	//这个桶实际上是将上面那个map的key value翻转了一下，因为对于同一个value可能有多个
    	//key，所以buckey的元素应该是个列表,第一次这么用列表
    	List<Integer>[] bucket = new List[nums.length+1];
    	
    	for(int key:map.keySet()){
    		int count = map.get(key);
    		if(bucket[count]==null){
    			ArrayList<Integer> temp = new ArrayList<Integer>();
    			temp.add(key);
    			bucket[count] = temp;
    		}else{
    			bucket[count].add(key);
    		}
    	}
    	
    	ArrayList<Integer> res = new ArrayList<Integer>();
    	for(int i=bucket.length-1;i>=0&&res.size()<k;i--){
    		if(bucket[i]!=null){
    			//这里addAll是因为题目说明了只有一个唯一解，是个特例
    			res.addAll(bucket[i]);
    		}
    	}
    	return res;
    }