LintCode 81 -- 数据流中位数

题目

中位数 II

数字是不断进入数组的，在每次添加一个新的数进入数组的同时返回当前新数组的中位数。

说明

中位数的定义：

• 中位数是排序后数组的中间值，如果有数组中有n个数，则中位数为A[(n-1)/2]。
• 比如：数组A=[1,2,3]的中位数是2，数组A=[1,19]的中位数是1。

样例

持续进入数组的数的列表为：[1, 2, 3, 4, 5]，则返回[1, 1, 2, 2, 3]

持续进入数组的数的列表为：[4, 5, 1, 3, 2, 6, 0]，则返回 [4, 4, 4, 3, 3, 3, 3]

持续进入数组的数的列表为：[2, 20, 100]，则返回[2, 2, 20]

分析

开始想到用线性的思想，意料之中的TLE。。。

最大最小堆算法：

复杂度

时间 O(NlogN) 空间 O(N)

思路

维护一个最大堆，一个最小堆。最大堆存的是到目前为止较小的那一半数，最小堆存的是到目前为止较大的那一半数，这样中位数只有可能是堆顶或者堆顶两个数的均值。而维护两个堆的技巧在于判断堆顶数和新来的数的大小关系，还有两个堆的大小关系。我们将新数加入堆后，要保证两个堆的大小之差不超过1。先判断堆顶数和新数的大小关系，有如下三种情况：最小堆堆顶小于新数时，说明新数在所有数的上半部分。最小堆堆顶大于新数，但最大堆堆顶小于新数时，说明新数将处在最小堆堆顶或最大堆堆顶，也就是一半的位置。最大堆堆顶大于新数时，说明新数将处在所有数的下半部分。再判断两个堆的大小关系，如果新数不在中间，那目标堆不大于另一个堆时，将新数加入目标堆，否则将目标堆的堆顶加入另一个堆，再把新数加入目标堆。如果新数在中间，那加到大小较小的那个堆就行了（一样大的话随便，代码中是加入最大堆）。这样，每次新加进来一个数以后，如果两个堆一样大，则中位数是两个堆顶的均值，否则中位数是较大的那个堆的堆顶。

代码

class Solution {
public:
    /**
     * @param nums: A list of integers.
     * @return: The median of numbers
     */
    
    //方法一：数据流中位数，维护两个结构 
     vector<int> medianII(vector<int> &nums) {
        // write your code here
        multiset<int> left, right;
        vector<int> res;
        bool flag = true;
        for (int n : nums) {
            int tmp = n;
            if (flag) {
                if (!right.empty() && n > *right.begin()) {
                    right.insert(n);
                    tmp = *right.begin();
                    right.erase(right.find(tmp));
                }
                left.insert(tmp);
            } else {
                if (!left.empty() && n < *left.rbegin()) {
                    left.insert(n);
                    tmp = *left.rbegin();
                    left.erase(left.find(tmp));
                }
                right.insert(tmp);
            }
            flag = !flag;
            res.push_back(*left.rbegin());
        }
        return res;
    } 
    
    /*方法二：线性处理，但是会超时*/
    vector<int> medianII_2(vector<int> &nums) {
        // write your code here
        if(nums.empty())
        {
            return vector<int>();
        }//if
        
       int len = nums.size();
       vector<int> ret,v;
       v.push_back(nums[0]);
       ret.push_back(nums[0]);
       
       for(int i=1; i<len; ++i)
       {
           v.push_back(nums[i]);
           ret.push_back(median(v));
       }//for
       
       return ret;
    }
    
    
    int median(vector<int> &nums)
    {
        if(nums.empty())
        {
            return 0;
        }//if
        
        int lhs = 0 , rhs = nums.size()-1;
        int mid = (lhs + rhs) / 2;
        
        int idx = partition(nums, lhs , rhs);
        while(idx != mid && lhs <= rhs)
        {
            if(idx < mid)
            {
                lhs = idx + 1;
            }else{
                rhs = idx - 1;
            }//if
            
            idx = partition(nums, lhs , rhs);
        }//while
        
        return nums[idx];
    }
    
    int partition(vector<int> &nums, int left, int high)
    {
        if(nums.empty() || left > high)
        {
            return -1;
        }//if
        
        int low = left-1, pivot = nums[high];
        for(int i=left; i<high; ++i)
        {
            if(nums[i] <= pivot)
            {
                ++low;
                exchange(nums[low], nums[i]);
            }//if
        }//for
        
        exchange(nums[low+1], nums[high]);
        return low+1;
    }//partition
    
    void exchange(int &a, int &b)
    {
        if(a == b)
        {
            return ;
        }//if
        
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
    }
};