堆的经典题目java实现（详细解析）

最常用的是最小堆和最大堆，先给出两者的java实现

//最小堆的实现
PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>(); //小顶堆
//最大堆的实现
PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(11,new Comparator<Integer>(){ //大顶堆，容量11
    public int compare(Integer i1,Integer i2){
        return i2-i1;
    }
});

1:出现频率最高的K个数字
题目：
找出数组中出现频率最高的K个数字。比如k=2,数组为[1,2,2,1,3,1],出现频率最高的两个数字是1和2

分析：
首先问频率，想到哈希表。哈希表可以统计数组中数字出现的频率；哈希表的键是数组中的值，哈希表的值是对应值出现的频率。
哈希表统计完后，建立最小堆，最小堆的作用是找出频率最高的K个数字。如果最小堆的大小小于K，直接把从数字到频率的映射添加到最小堆；若最小堆的大小等于K，先判断待添加的数字的频率和顶堆的映射的频率，若堆顶映射的频率大于待添加的数字的频率，说明最小堆中已经存在K个频率最高的数字，则不要加入；若堆顶映射的频率小于待添加的数字的频率，则先弹出最小堆的顶堆对应的映射，在把待添加的映射加到最小堆中。

    public LinkedList<Integer> findKthFrequent(int []nums,int k){
    	Map<Integer, Integer>count=new HashMap<>();
    	for (int i=0;i<nums.length;i++) {
    		count.put(nums[i], count.getOrDefault(nums[i], 0)+1);
    	}
    	PriorityQueue<Map.Entry<Integer, Integer>> minHeap = new PriorityQueue<>(new Comparator<>() {
    		public int compare(Map.Entry<Integer, Integer>e1,Map.Entry<Integer, Integer>e2) {
    			return e1.getValue()-e2.getValue();
    		}
		}); 
    	for (Map.Entry<Integer, Integer>entry:count.entrySet()) {
    		if (minHeap.size()<k) {
    			minHeap.offer(entry);
    		}
    		else {
    			if (minHeap.peek().getValue()<entry.getValue()) {
    				minHeap.poll();
    				minHeap.offer(entry);
    			}
    		}
    	}
    	LinkedList<Integer>result=new LinkedList<>();
    	for (Map.Entry<Integer, Integer>entry:minHeap) {
    		result.add(entry.getKey());
    	}
    	return result;
    }

时间复杂度为O(nlogk),空间复杂度为O(n),因为开了个哈希表。

2：和最小的K个数对
题目：
给两个递增的数组，从两个数组中各取一个数字u和v组成数对（u，v），请找出和最小的K个数对。如输入[1,5,13,21]和[2,4,9,15],和最小的3个数对为(1,2),（1,4），（2，5）；对应输出[ [1,2], [1,4] ,[2,5] ]

分析：
用最大堆存储这和最小的K个数对。当堆中数对的个数小于K时，直接加入新的数对，若个数等于K时，判断堆顶的数对和待加入的数对的和的大小；每次都用堆中数对之和最大的数对和待加入的数对进行判断，这也是为什么用最大堆的原因。
还有个条件我们没用到，就是数组是递增的。因为是找前K个数对，所以只用考虑两个数组中前K个数字就行，为什么？假设第一个数组的第K+1个数和第二个数组的任意一个数组合，都可以找到K个比这个数对和最小的数对，所以只用考虑第一个数组的前K个数，同理，只用考虑第二个数组的前K个数。

    public List<List<Integer>> findKSmallest(int []nums1,int []nums2,int k){
    	PriorityQueue<int[]>maxHeap=new PriorityQueue<>(new Comparator<>() {
    		public int compare(int []p1,int []p2) {
    			return p2[1]+p2[0]-p1[0]-p1[1];
    		}
		});
    	for (int i=0;i<Math.max(k, nums1.length);i++) {
    		for (int j=0;j<Math.max(k, nums2.length);j++) {
    			if (maxHeap.size()<k) {
    				maxHeap.offer(new int[] {nums1[i],nums2[j]});
    			}
    			else {
    				int root[]=maxHeap.peek();
    				if (root[0]+root[1]>nums1[i]+nums2[j]) {
    					maxHeap.poll();
    					maxHeap.offer(new int[] {nums1[i],nums2[j]});
    				}
    			}
    		}
    	}
    	List<List<Integer>>result=new LinkedList<>();
    	while(!maxHeap.isEmpty()) {
    		int []root=maxHeap.poll();
    		result.add(Arrays.asList(root[0],root[1]));
    	}
    }

菜鸟一枚，有问题请指出~