堆---第K大数

堆最重要的三个方法：

• heapify：建堆：找到第一个非叶子节点，比较这个节点和它的左右孩子，调整，如果交换了父节点和它的孩子的话，还需要再将交换后的孩子节点再执行相同的操作：比较孩子的孩子，当这个非叶子节点调整好后，再依次调整前面的节点，直到树根为止。
• 下潜：比如说大顶锥，比较当前节点和它的孩子，保证满足大顶锥，如果有交换，则将交换后的这个孩子节点位置再执行下潜逻辑。
• 上浮：依次找本节点和它的父节点，比较大小，要求满足堆的定义，如果交换了，则将交换后的这个父节点位置再执行上浮，直到根或者没有交换为止。

1. 数组中第K大元素-力扣 215 题

使用优先级队列也就是堆，找第K个最大元素，我们建立一个K个元素的小顶锥，保存的就是数组中前K个最大值，小顶堆的堆顶就是第K大的元素
步骤：首先建立一个K个元素的小顶堆，然后再从数组取第K+1到第length个元素，每一个元素都与堆顶元素比较，比堆顶元素大的话，替换掉，然后调整堆，这样最后堆中就保留了前K大的元素，取堆顶就是第K大元素。

import java.util.Comparator;
import java.util.PriorityQueue;

public class Solution {

    public int findKthLargest(int[] nums, int k) {
        int len = nums.length;
        // 使用一个含有 k 个元素的最小堆，PriorityQueue 底层是动态数组，为了防止数组扩容产生消耗，可以先指定数组的长度
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(k, Comparator.comparingInt(a -> a));
        // Java 里没有 heapify ，因此我们逐个将前 k 个元素添加到 minHeap 里
        for (int i = 0; i < k; i++) {
            minHeap.offer(nums[i]);
        }

        for (int i = k; i < len; i++) {
            // 看一眼，不拿出，因为有可能没有必要替换
            Integer topElement = minHeap.peek();
            // 只要当前遍历的元素比堆顶元素大，堆顶弹出，遍历的元素进去
            if (nums[i] > topElement) {
                // Java 没有 replace()，所以得先 poll() 出来，然后再放回去
                minHeap.poll();
                minHeap.offer(nums[i]);
            }
        }
        return minHeap.peek();
    }
}

2. 数据流中第K大元素-力扣 703 题

class KthLargest {
    // 堆
    PriorityQueue<Integer> pq;
    int k;
    public KthLargest(int k , int[] nums) {
        this.k = k;
        pq = new PriorityQueue<Integer>();
        for (int x : nums) {
            add(x);
        }
    }   
    public int add(int val) {
        pq.offer(val);
        if (pq.size() > k) {
            pq.poll();
        }
        return pq.peek();
    }
}

3. 数据流的中位数-力扣 295 题

思路：用两个堆来求中位数，左面堆为大顶堆，右面堆为小顶堆，将数据分为两部分，左边大顶堆都小于右边小顶堆，右边小顶堆都大于左边大顶堆，这样当数据为偶数时两个堆顶相加相除就是中位数，当数据为奇数时，我们定义左边堆比右边堆多一个，那取出左边堆的堆顶就是中位数。

添加元素逻辑：要保证将数据均分到两个堆，并且只容许左边堆比右边堆多一个、或者两个堆相等，这样才能找出中位数。

1. 判断两个堆的size，当相同时，我们要将这个数添加到左边，但是添加完后要保证左堆都小于右堆，如果直接将这个数添加到左堆可能导致左堆不一定都小于右堆，所以添加的逻辑是：先将这个数添加到右堆，然后取出右堆的堆顶，也就是右堆的最小的数，将这个数再添加到左堆，这样就保证了左堆都小于右堆。
2. 判断两个堆的size，当不相同时，那说明右堆比左堆少一个数，我们将这个数添加到右堆：先将这个数添加到左堆，取出左堆的堆顶，也就是左堆的最大的数，将这个最大的数添加到右堆

判断中位数逻辑：

• 当size相同时，取出两个堆的堆顶，相加除2
• 当size不相同时，取出左堆的堆顶，就是中位数。

class MedianFinder {
    PriorityQueue<Integer> leftMax;
    PriorityQueue<Integer> rightMin;
    public MedianFinder() {

        leftMax = new PriorityQueue<Integer>((a, b) -> (b - a));
        rightMin = new PriorityQueue<Integer>((a, b) -> (a - b));

    }
    
    public void addNum(int num) {
        if (leftMax.size() == rightMin.size()) {
            rightMin.offer(num);
            leftMax.offer(rightMin.poll());
        } else {
            leftMax.offer(num);
            rightMin.offer(leftMax.poll());
        }
    }
    
    public double findMedian() {
         if (leftMax.size() == rightMin.size()) {
            return (leftMax.peek() + rightMin.peek()) / 2.0;
        } else {
            return leftMax.peek();
        }
    }
}