数据流中的中位数

题目描述

　　如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

　　解法1：数组不排序，基于Partition函数找中位数。插入数字和找出中位数的时间复杂度分别为O(1)和O(n)

class Solution {
public:
    int Partition(vector<int> &arr, int begin, int end)
    {
        int tmp=arr[begin];
        while(begin<end)
        {
            while(begin<end && arr[end]>=tmp)--end;
            arr[begin]=arr[end];
            while(begin<end && arr[begin]<=tmp)++begin;
            arr[end]=arr[begin];
        }
        arr[begin]=tmp;
        return begin;
    }
    void Insert(int num)
    {
        arr.push_back(num);
    }
    double GetMedian()
    {
        int length=arr.size();
        if(length==0)return 0;
        if(length & 1)
        {
            int begin=0;
            int end=length-1;
            while(true)
            {
                int mid=Partition(arr, begin, end);
                if(mid==length/2)break;
                if(mid>length/2)end=mid-1;
                else begin=mid+1;
            }
            return arr[length/2];
        }else{
            int begin=0;
            int end=length-1;
            while(true)//确定length/2位置上的数
            {
                int mid=Partition(arr, begin, end);
                if(mid==length/2)break;
                if(mid>length/2)end=mid-1;
                else begin=mid+1;
            }
            begin=0;
            end=length/2-1;
            while(true)//确定length/2-1位置上的数
            {
                int mid=Partition(arr, begin, end);
                if(mid==end)break;
                else begin=mid+1;
            }
            return (arr[length/2-1]+arr[length/2])*1.0/2;
        }
    }
private:
    vector<int> arr;
};

　　解法2：数组插入元素后保持排序，故插入数字和找出中位数的时间复杂度分别为O(n)和O(1)

class Solution {
public:
    void Insert(int num)
    {
        arr.push_back(num);
        size_t idx;
        for(idx=arr.size()-2; idx>=0; --idx)//后移
        {
            if(arr[idx]>num)arr[idx+1]=arr[idx];
            else break;
        }
        arr[idx+1]=num;//插入
    }
    double GetMedian()
    { 
        int length=arr.size();
        if(length & 1)
        {
            return arr[length/2];
        }else{
            return (arr[length/2-1]+arr[length/2])*1.0/2;
        }
    }
private:
    vector<int> arr;
};

　　解法3：用一个大顶堆实现数组左边的数据容器，用一个小顶堆实现数组右边的数据容器。插入数字和找出中位数的时间复杂度分别为O(logn)和O(1)

class Solution {
public:
    void Insert(int num)
    {
        if((max.size()+min.size()) & 1)//如果总数是奇数个，插入大顶堆，并保证大顶堆的所有数据都小于小顶堆中的数据
        {
            if(min.size()>0 && num>min[0])
            {
                min.push_back(num);
                push_heap(min.begin(), min.end(), std::greater<int>());
                num=min[0];
                pop_heap(min.begin(), min.end(), std::greater<int>());
                min.pop_back();
            }
            max.push_back(num);
            push_heap(max.begin(), max.end(), std::less<int>());
        }else{//如果总数是偶数个，插入小顶堆，并保证大顶堆中所有数据都小于小顶堆中的数据
            if(max.size()>0 && num<max[0])
            {
                max.push_back(num);
                push_heap(max.begin(), max.end(), std::less<int>());
                num=max[0];
                pop_heap(max.begin(), max.end(), std::less<int>());
                max.pop_back();
            }
            min.push_back(num);
            push_heap(min.begin(), min.end(), std::greater<int>());
        }
    }
    double GetMedian()
    {
        if(min.size()==0)return 0;
        if((min.size()+max.size()) & 1)
        {
            return min[0];
        }else{
            return (min[0]+max[0])*1.0/2;
        }
    }
private:
    vector<int> max;
    vector<int> min;
};