数据流中的中位数

题目描述

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

解题思路

【java】这里讨论两种方法：
一：代码复杂：减少不必要插入，提高效率
二：代码大大简化：可能有不必要插入，效率有所降低
思路解析===================
思考：如何得到一个数据流中的中位数？
如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。
如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

解法1 - 代码复杂：

分析：对于海量数据和流的数据，用最大堆和最小堆来管理我们希望 数据分为[小]|[大]两个部分，细化一点
[最大堆 | 左边最大 leftMax] 右边最小rightMin | 最小堆]

定义一个规则：保证左边和右边个数相差不大于1，且左边小于右边

1. 数据是偶数的时候 insert的数据进入 [右边，最小堆]中
   1.1 当插入的数字cur > leftMax时，直接插入到[右边，最小堆]中
   1.2 当插入的数字cur < leftMax时，为了保证左边小于右边，先把cur插入[最大堆|左边最大leftMax]中，然后把leftMax放入[右边最小rightMin|最小堆]中就可以保证： 左边 < 右边

2.数据是奇数的时候 insert的数据进入 [左边，最大堆]中
2.1当插入的数字cur < rightMin时，直接插入到[左边，最小堆]中
2.2当插入的数字cur > rightMin时，为了保证左边小于右边，
先把cur插入[右边最小rightMin|最小堆]中，
然后把rightMin放入[最大堆|左边最大leftMax]中
就可以保证： 左边 < 右边
最后：
如果是偶数：中位数mid= (leftMax+right)/2
如果是奇数：中位数mid= leftMax 因为先插入到左边，再插入到右边，为奇数时，中位数就是mid

// 降序就是最大堆，lambda表达式了解下

private static PriorityQueue<Integer> leftHeap = new PriorityQueue<>((x, y) -> y - x);
//升序就是最小堆
private static PriorityQueue<Integer> rightHeap = new PriorityQueue<>();
//当前是奇数还是偶数
private static boolean isOdd = true;
public static void Insert(Integer num) {
    if(isOdd) {//数据是奇数的时候 insert的数据进入 [左边，最大堆]中
        if(leftHeap.isEmpty()) {
            leftHeap.add(num);
        }
        else {//这个时候rightHeap一定不是null，就不讨论了。考虑鲁棒性可以讨论
            int rightMin = rightHeap.peek();
            if(num <= rightMin) {//直接插入到[左边，最小堆]中
                leftHeap.add(num);
            }else {
                rightHeap.add(num);//先把cur插入[右边最小rightMin|最小堆]中
                leftHeap.add(rightHeap.poll());//然后把rightMin放入[最大堆|左边最大leftMax]中
            }
        }
    }else {//数据是偶数的时候 insert的数据进入 [右边，最小堆]中
        //这个时候leftHeap一定不是null，就不讨论了。考虑鲁棒性可以讨论
        int leftMax = leftHeap.peek();
        if(num >= leftMax) {//直接插入到[右边，最小堆]中
            rightHeap.add(num);
        }else {
            leftHeap.add(num);//先把cur插入[右边最小rightMin|最小堆]中，
            rightHeap.add(leftHeap.poll());//然后把rightMin放入[最大堆|左边最大leftMax]中
        }
    }
    isOdd = !isOdd;//改变奇偶性
}

public static Double GetMedian() {
    if(leftHeap.isEmpty()) return 0.0;
    if(!isOdd)//这里插入num改变了奇偶性，这里是奇数的意思
        return leftHeap.peek() / 1.0;
    else
        return (leftHeap.peek() + rightHeap.peek()) / 2.0;
}

解法2 - 简化代码

取消了判断过程，直接插入到对面的堆中，然后再转移到自己的堆中
但是！！！时间复杂度提高，每次都插入时间复杂度O(log n)这是很可怕的
定义一个规则：不要判断了
1.数据是偶数的时候 insert的数据进入 [右边，最小堆]中
先把cur插入[最大堆|左边最大leftMax]中，
然后把leftMax放入[右边最小rightMin|最小堆]中
就可以保证： 左边 < 右边
2.数据是奇数的时候 insert的数据进入 [左边，最大堆]中
先把cur插入[右边最小rightMin|最小堆]中，
然后把rightMin放入[最大堆|左边最大leftMax]中
就可以保证： 左边 < 右边
最后：
如果是偶数：中位数mid= (leftMax+right)/2
如果是奇数：中位数mid= leftMax看看是不是简化了很多

import java.util.PriorityQueue;
import java.util.Comparator;
public class Solution {

    //小顶堆
    private PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    //大顶堆
    private PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(15, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });

    //记录偶数个还是奇数个
    int count = 0;
    //每次插入小顶堆的是当前大顶堆中最大的数
    //每次插入大顶堆的是当前小顶堆中最小的数
    //这样保证小顶堆中的数永远大于等于大顶堆中的数
    //中位数就可以方便地从两者的根结点中获取了
    public void Insert(Integer num) {
        //个数为偶数的话，则先插入到大顶堆，然后将大顶堆中最大的数插入小顶堆中
        if(count % 2 == 0){
            maxHeap.offer(num);
            int max = maxHeap.poll();
            minHeap.offer(max);
        }else{
            //个数为奇数的话，则先插入到小顶堆，然后将小顶堆中最小的数插入大顶堆中
            minHeap.offer(num);
            int min = minHeap.poll();
            maxHeap.offer(min);
        }
        count++;
    }

    public Double GetMedian() {
        //当前为偶数个，则取小顶堆和大顶堆的堆顶元素求平均
        if(count % 2 == 0){
            return new Double(minHeap.peek() + maxHeap.peek())/2;
        }else{
            //当前为奇数个，则直接从小顶堆中取元素即可
            return new Double(minHeap.peek());
        }
    }


}