[LeetCode][C++]数据流的中位数

数据流的中位数

中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。

例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5

设计一个支持以下两种操作的数据结构：

void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。

示例：
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2

进阶:
如果数据流中所有整数都在 0 到 100 范围内，你将如何优化你的算法？
如果数据流中 99% 的整数都在 0 到 100 范围内，你将如何优化你的算法？

---

思路：

1. 创建2个堆，分别为大顶堆，小顶堆。其中，大顶堆用于管理中位数之前的数，小顶堆用于管理中位数之后的数。
2. 在数据压入时，得考虑：
   （1）第1个数据，首先压入大顶堆。
   （2）第2个数据，得判断该数据与大顶堆堆顶数据的大小关系，若大于，则直接压入小顶堆。若小于，则将该数与大顶堆堆顶数据交换，再压入小顶堆。
   （3）第3个及以后的数据，首先判断该数与大顶堆堆顶、小顶堆堆顶之间的关系，再进行数据交换和判断插入的堆，具体看代码。
3. 数据压入完后，判断大顶堆数据数目与小顶堆数据数目的大小，若相等，即数据流的个数为偶数，取两个堆顶元素，作和除以2即可得中位数。若大顶堆数据数目大于小顶堆数据数目，即数据流的个数为奇数，取大顶堆堆顶元素，即为中位数。

代码：

class MedianFinder {
public:
    
    priority_queue<int,vector<int>, less<int>> big_q;       //大顶堆
    priority_queue<int,vector<int>, greater<int>> small_q;  //小顶堆
    /** initialize your data structure here. */
    MedianFinder() {
        
    }
    
    void addNum(int num) {
        int tmp_big,tmp_small;
        //第1次压入数据，直接压入大顶堆
        if(big_q.size()==0)
        {
            big_q.push(num);
            return;
        }
        //第2次压入数据，先判断要压入的数据与大顶堆顶部之间的大小
        if(big_q.size()==1 && small_q.size()==0)
        {
            
            if(num<big_q.top()) //若小于，则取出大顶堆顶部数据，换成num
            {
                tmp_big=big_q.top();
                big_q.pop();
                big_q.push(num);
                small_q.push(tmp_big);
            }else{
                small_q.push(num);
            }            
            return;
        }
        //第3次以及后面押入数据
        tmp_big=big_q.top();
        tmp_small=small_q.top();
        if(num<tmp_big)    //判断num与大顶堆顶部的大小关系
        {
            big_q.pop();
            big_q.push(num);
            num=tmp_big;
        }else if(num>tmp_small)  //判断num与小顶堆顶部的大小关系
        {
            small_q.pop();
            small_q.push(num);
            num=tmp_small;
        }
        if(big_q.size()==small_q.size())    //判断num要压入的顶堆
        {
            big_q.push(num);
        }else{
            small_q.push(num);
        }        
    }
    
    double findMedian() {
        int a1,a2;
        if(big_q.size()== 0 && small_q.size()==0)
        {
            return 0;
        }
        if(big_q.size()==small_q.size())
        {
            int a1=big_q.top();
            int a2=small_q.top();
            return (a1+a2)/2.;
        }else{
            return big_q.top();
        }
        
    }
};

简化代码：

class MedianFinder {
public:

    priority_queue<int>  low;
    priority_queue<int,vector<int>, greater<int>> hi;

    /** initialize your data structure here. */
    MedianFinder() {

    }
    
    void addNum(int num) {
        low.push(num);
        
        hi.push(low.top());
        low.pop();

        if(low.size()<hi.size())
        {
            low.push(hi.top());
            hi.pop();
        }
    }
    
    double findMedian() {
        return low.size()>hi.size()?low.top()*1.:(low.top()+hi.top())*1./2;
    }
};

复杂度：
时间复杂度：$O(5\cdot \log n)+O(1)\approx O(\log n)$。
最坏情况下，从顶部有三个堆插入和两个堆删除。每一个都需要花费 $O(logn)$ 时间。
找到平均值需要持续的 O(1) 时间，因为可以直接访问堆的顶部。
空间复杂度：$O(n)$ 用于在容器中保存输入的线性空间。

结果：