[leetcode]堆排序 求前k大的数

前一篇博客中写到了排序算法，其中包含一个堆排序，因此本篇博客讲解堆这个数据结构及其应用。

关于最大堆最小堆以及初始建堆和整理堆在上篇博客中有提及，此处不再赘述。下面讲解一个堆的重要应用，求n个数中前k个大的数，一般思路是将n个数排序，取前k个数，但当n的数量庞大无法加载到内存时，需要另外一种思路，即利用堆，只维护k个树的大小而不需维护全部。

具体的思路是：先建一个k个数的小堆，然后从k+1个数往后的值与堆顶元素比较，若此数比堆顶元素大，就将堆顶元素用这个数替换，然后重新调整堆，以此向后重复上述过程，直到将N个数比较完成，那么此时组成这个堆的k个元素就是前k个大的数。

下面以leetcode上的题为例，实现这个求解过程。

347. Top K Frequent Elements

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

java中的优先队列PriorityQueue是一个具有小根堆性质的数据结构，并且可以通过提供comparator比较器实现大根堆或自定义排序。本题中要求统计数字出现次数，使用hashmap，并自定义数据结构完成数字到出现次数的一一映射，通过上面的思路，维护大小为k的小根堆，最后逆向输出。

class KeyValue{
        Integer key;
        Integer value;
        public KeyValue(Integer key,Integer value) {
            this.key=key;
            this.value=value;
        }
    }
    public List<Integer> topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        //统计数字出现频率
        for(int i=0;i<nums.length;i++) {
            if(map.containsKey(nums[i])) {
                map.put(nums[i],map.get(nums[i])+1);
            } else {
                map.put(nums[i],1);
            }
        }
        Iterator iter = map.entrySet().iterator();
        Queue<KeyValue> queue = new PriorityQueue<>(k,new Comparator<KeyValue>() {
                    public int compare(KeyValue value1,KeyValue value2) {
                        return value1.value-value2.value;
               }    
            });
        int cnt=0;
        while(iter.hasNext()) { //对hashmap中元组遍历
            Map.Entry entry = (Map.Entry) iter.next();
            KeyValue tmp = new KeyValue((Integer) entry.getKey(),(Integer) entry.getValue());
            if(cnt<k) { //k大小优先队列
                queue.add(tmp);
            } else if(tmp.value>queue.peek().value) {   //比堆顶大，替换堆顶
                queue.poll();
                queue.add(tmp);
            }
            cnt++;
        }
        List<Integer> ret = new ArrayList<>();
        //小根堆逆向输出，频率大的在前  
        for(int i=0;i<k;i++) {
            ret.add(0,queue.poll().key);
        }
        return ret;
    }