0
点赞
收藏
分享

微信扫一扫

【JZ41 数据流中的中位数】

描述

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

数据范围:数据流中数个数满足 1 ≤ n ≤ 1000 ,大小满足 1 ≤ val ≤ 1000

进阶: 空间复杂度 O(n) , 时间复杂度 O(nlogn)

示例1

输入:[5,2,3,4,1,6,7,0,8]

返回值:"5.00 3.50 3.00 3.50 3.00 3.50 4.00 3.50 4.00 "

说明:数据流里面不断吐出的是5,2,3...,则得到的平均数分别为5,(5+2)/2,3...    

示例2

输入:[1,1,1]

返回值:"1.00 1.00 1.00 "

方法一:暴力方法

对于一组数据,我们可以用 vector<int> arr 来存取。如果对 vector 排好序,则很容易求出中位数。如果 vector 的大小为 sz

  • 如果 sz 为奇数,假如为3,即 [0 1 2] ,则中位数就是中间的那个数 arr[1]

  • 如果 sz 为偶数,假如为4,即 [0 1 2 3] , 则中位数就是中间两个数的加权平均数。即 (arr[1] + arr[2]) / 2

代码:

class Solution {
public:
    #define SCD static_cast<double>
    vector<int> v;
    void Insert(int num)
    {
        v.push_back(num);
 
    }
 
    double GetMedian()
    {
        sort(v.begin(), v.end());
        int sz = v.size();
        if (sz & 1) {
            return SCD(v[sz >> 1]);
        }
        else {
            return SCD(v[sz >> 1] + v[(sz - 1) >> 1]) / 2;
        }
    }
 
};

方法二:插入排序

对于方法一,可以发现有个优化的地方。

方法一中 GetMEdian() 操作,是每次都对整个 vector 调用排序操作。
但是其实每次都是在一个有序数组中插入一个数据。因此可以用插入排序。
所以:

  • Insert() 操作可改为插入排序

  • GetMedian() 操作可直接从有序数组中获取中位数

代码:

class Solution {
public:
    #define SCD static_cast<double>
    vector<int> v;
    void Insert(int num)
    {
        if (v.empty()) {
            v.push_back(num);
        }
        else {
            auto it = lower_bound(v.begin(), v.end(), num);
            v.insert(it, num);
        }
    }
 
    double GetMedian()
    {
        int sz = v.size();
        if (sz & 1) {
            return SCD(v[sz >> 1]);
        }
        else {
            return SCD(v[sz >> 1] + v[(sz - 1) >> 1]) / 2;
        }
    }
 
};

方法三:堆

中位数是指:有序数组中中间的那个数。则根据中位数可以把数组分为如下三段:
[0 ... median - 1], [median], [median ... arr.size() - 1],即 [中位数的左边,中位数,中位数的右边]

那么,如果我有个数据结构保留 [0...median-1 ]的数据,并且可以O(1)时间取出最大值,即arr[0…median-1] 中的最大值相对应的,如果我有个数据结构可以保留[median + 1 ... arr.size() - 1] 的数据, 并且可以O(1)时间取出最小值,即 arr[median + 1 … arr.size() - 1] 中的最小值。
然后,我们把[median]即中位数,随便放到哪个都可以。

假设 [0 ... median - 1] 的长度为 l_len, [median + 1 ... arr.sise() - 1] 的长度为 r_len.

  1. 如果l_len == r_len + 1, 说明,中位数是左边数据结构的最大值

  2. 如果l_len + 1 == r_len, 说明,中位数是右边数据结构的最小值

  3. 如果l_len == r_len, 说明,中位数是左边数据结构的最大值与右边数据结构的最小值的平均值。

说了这么多,一个数据结构可以 O(1) 返回最小值的,其实就是小根堆,O(1) 返回最大值的,其实就是大根堆。并且每次插入到堆中的时间复杂度为O(logn)

所以,GetMedian()操作算法过程为:

  • 初始化一个大根堆,存中位数左边的数据,一个小根堆,存中位数右边的数据
  • 动态维护两个数据结构的大小,即最多只相差一个

代码:

class Solution {
public:
    #define SCD static_cast<double>
    priority_queue<int> min_q; // 大顶推
    priority_queue<int, vector<int>, greater<int>> max_q; // 小顶堆
 
    void Insert(int num)
    {
 
        min_q.push(num); // 试图加入到大顶推
 
        // 平衡一个两个堆
        max_q.push(min_q.top());
        min_q.pop();
 
       if (min_q.size() < max_q.size()){
           min_q.push(max_q.top()); 
           max_q.pop();
       }
 
    }
 
    double GetMedian()
    {
        return min_q.size() > max_q.size() ? SCD(min_q.top()) : SCD(min_q.top() + max_q.top()) / 2;
    }

};

或者代码:

class Solution {
public:
    //大顶堆,元素数值较小
    priority_queue<int> min;
    //小顶堆,元素数值都比大顶堆大
    priority_queue<int, vector<int>, greater<int>> max;
    //维护两个堆,取两个堆顶部即可
    void Insert(int num) {     
        //先加入较小部分
        min.push(num);
        //将较小部分的最大值取出,送入到较大部分
        max.push(min.top());
        min.pop();
        //平衡两个堆的数量
        if(min.size() < max.size()){
            min.push(max.top());
            max.pop();
        }      
    }
    double GetMedian() {
        //奇数个
        if(min.size() > max.size())
            return (double)min.top();
        else
            //偶数个
            return (double)(min.top() + max.top()) / 2;
    }
 
};
举报

相关推荐

0 条评论