算法必刷系列之堆

堆

堆的插入和删除操作是十分复杂的，因此不需要我们手动创建和维护堆。在Java中，优先队列底层是由堆来实现的，因此堆的相关操作可以借助优先队列的API。堆可以解决查找和排序相关的问题。查找主要是查找数据中第几大/小数据的问题。遵循“查大用小，查小用大”的原则，排序主要是通过对堆排序解决排序问题。遵循“升序用小，降序用大”的原则

数组中第K大元素

leetcode215
本题可以使用选择，快排和堆查找实现

按照“查大用小，查小用大”的原则，使用小顶堆，堆的大小设置K，堆未满时，加入元素。达到容量之后，比较遍历元素与堆顶元素的关系，大于则移除堆顶元素，加入当前元素，否则不做处理，循环结束后，堆顶元素即为数组中第K大元素。

public int findKthLargest(int[] nums, int k) {
    PriorityQueue<Integer> minHeap = new PriorityQueue<>(k,(a,b)->a-b);
    for (int i = 0; i < k; i++) {
        minHeap.add(nums[i]);
    }
    for (int i = k; i < nums.length; i++){
        Integer temp = minHeap.peek();
        if(nums[i]>temp){
            minHeap.poll();
            minHeap.offer(nums[i]);
        }
    }
    return minHeap.poll();
}

堆排序

按照“升序用小，降序用大”的原则，遍历数组，依次将元素加入堆中之后不断移除堆顶元素，即为当前堆中的最小元素，依次放入数组中，达到升序效果

public static void heapSort(int[] array) {
    PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    for (int num : array) {
        minHeap.offer(num);
    }
    for (int i = 0; i < array.length; i++) {
        array[i] = minHeap.poll();
    }
}

合并K个有序链表

leetcode23
合并K个有序链表之前在链表章节已经提及过，我们自己比较并合并的代码还是比较复杂的。使用堆可以简化操作。创建一个最小堆，将各个链表的首节点放入堆中，然后移除堆顶元素，放入虚拟头节点之后，如果移除元素之后仍有节点，加入堆中。如此，当堆为空时，链表的合并也就完成了

public ListNode mergeKLists(ListNode[] lists) {
    PriorityQueue<ListNode> minHeap = new PriorityQueue<>((node1, node2) -> (node1.val - node2.val));
    for (int i = 0; i < lists.length; i++) {
        if(lists[i]!=null){
            minHeap.offer(lists[i]);
        } 
    }
    ListNode vhead = new ListNode(-1);
    ListNode current = vhead;
    while (!minHeap.isEmpty()) {
        ListNode node = minHeap.poll();
        current.next = node;
        current = node;
        if (current.next!=null){
            minHeap.offer(current.next);
        }
    }
    return vhead.next;
}

数据流中位数

leetcode295
查大用小，查小用大，查中间则需要两个堆，一个最大堆，一个最小堆，遍历元素，当最小堆为空或者当前元素大于最小堆堆顶元素时，放入最小堆，否则放入最大堆，当两个堆的元素数量相差大于1时，数量多的堆移除堆顶元素，放入另一个堆。如此，中位数或为两个堆顶元素的均值，或者为数量多的堆的堆顶元素

class MedianFinder {
    PriorityQueue<Integer> minHeap;
    PriorityQueue<Integer> maxHeap;

    public MedianFinder() {
        minHeap = new PriorityQueue<Integer>((a, b) -> a - b);
        maxHeap = new PriorityQueue<Integer>((a, b) -> b - a);
    }
    
    public void addNum(int num) {
        if (minHeap.isEmpty() || num > minHeap.peek()) {
            minHeap.offer(num);
            if (minHeap.size() - maxHeap.size() > 1) {
                maxHeap.offer(minHeap.poll());
            }
        } else {
            maxHeap.offer(num);
            if (maxHeap.size() - minHeap.size() > 1) {
                minHeap.offer(maxHeap.poll());
            }
        }
    }
    
    public double findMedian() {
        if (minHeap.size() == maxHeap.size()) {
            return (minHeap.peek() + maxHeap.peek()) / 2.0;
        }else{
            return minHeap.size()>maxHeap.size()? minHeap.peek() : maxHeap.peek();
        }
    }
}