Top K Frequent Elements

最新推荐文章于 2024-09-27 15:30:00 发布

愤怒的猴子

最新推荐文章于 2024-09-27 15:30:00 发布

阅读量295

点赞数

分类专栏： leetcode 文章标签： leetcode treemap comparator

本文链接：https://blog.csdn.net/yeshiwu/article/details/52738998

版权

leetcode 专栏收录该内容

175 篇文章 0 订阅

订阅专栏

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 logn), where n is the array's size.

这个题不难，就是复习下treemap的用法。

下面的工具类可以将Hashmap排序。将Hashmap转变成LinkedHashMap。

class MapUtil  
{  
    public static <K, V extends Comparable<? super V>> Map<K, V>   
        sortByValue( Map<K, V> map )  
    {  
        List<Map.Entry<K, V>> list =  
            new LinkedList<Map.Entry<K, V>>( map.entrySet() );  
        Collections.sort( list, new Comparator<Map.Entry<K, V>>()  
        {  
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )  
            {  
                return (o1.getValue()).compareTo( o2.getValue() );  
            }  
        } );  
  
        Map<K, V> result = new LinkedHashMap<K, V>();  
        for (Map.Entry<K, V> entry : list)  
        {  
            result.put( entry.getKey(), entry.getValue() );  
        }  
        return result;  
    }  
}

AC代码：（当然可以用上面的方法做）

public class Solution {
    class myComparator implements Comparator<Integer>{
		Map<Integer, Integer> map;
		
		public myComparator(Map<Integer, Integer> map) {
			this.map=map;
		}
		@Override
		public int compare(Integer o1, Integer o2) {
			//大于，-1是降序，1是升序
			if(map.get(o1)>map.get(o2))
				return -1;
			return 1;
		}
	}
	public List<Integer> topKFrequent(int[] nums, int k) {	
		List<Integer> result=new ArrayList<Integer>();
        Map<Integer, Integer> map=new TreeMap<Integer, Integer>();
        for(int i=0;i<nums.length;i++){
        	if(!map.containsKey(nums[i])){
        		map.put(nums[i], 1);
        	}else{
        		map.put(nums[i], map.get(nums[i])+1);
        	}
        }
        Comparator<Integer> myComparator=new myComparator(map);
        Map<Integer, Integer> treemap=new TreeMap<Integer, Integer>(myComparator);
        treemap.putAll(map);
        for (Integer key : treemap.keySet()) {
			result.add(key);
			k--;
			if(k==0){
				break;
			}
		}
        return result;
    }
}