剑指offer-面试题 41：数据流中的中位数

最新推荐文章于 2020-01-06 22:46:39 发布

wchzh2015

最新推荐文章于 2020-01-06 22:46:39 发布

阅读量213

点赞数

分类专栏：剑指 offer

本文链接：https://blog.youkuaiyun.com/wchzh2015/article/details/88878919

版权

剑指 offer 专栏收录该内容

56 篇文章

订阅专栏

本文介绍了一种高效计算流数据中位数的方法，利用最大堆和最小堆动态维护数据流中的中位数，适用于数据随时间变化的场景。通过平衡两堆之间的元素数量，可以在O(logn)的时间复杂度内完成数据插入，并能在O(1)时间内获取当前数据流的中位数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

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

对于C++ STL 中的堆的相关操作可以查看此博客【C++ STL应用与实现】72: 标准库里的堆--如何使用标准库的heap算法

算法思想：

由于数据是从一个数据流中读出来的，因而数据的数目会随着时间的变化而增加。这是一个在线算法。由于读出的数据不是已经排序好的。

如果使用数组或者是链表，还要考虑排序的情况。排序好的数组和链表，插入的时间复杂度是O(n)，得到中位数的时间复杂度O(1)。
使用二叉搜索树，可以把插入新数据的平均时间降低到O(logn)。但是最坏的情况是，二叉搜索树极度不平衡，会像一个链表，插入的时间复杂度是O(n)，得到中位数的时间复杂度也是O(n)。
可以考虑使用AVL树和堆结构，下面使用的是堆结构。

数据结构	插入的时间复杂度	得到中位数的时间复杂度
没有排序的数组	O(1)	O(n)
排序的数组	O(n)	O(1)
排序的链表	O(n)	O(1)
二叉搜索树	平均O(logn)，最差O(n)	平均O(logn)，最差O(n)
AVL树	O(logn)	O(1)
最大堆和最小堆	O(logn)	O(1)

解法：

如果数据就是已经排序好的，这是我们最希望看到的情况，然后事实不可能是这样的，（你想太多）。

假定数据就是从小到大排序好的，且数量为偶数，那么我们就是取前 n/2 的数据的最大值和后 n/2 的数据的最小值的均值。
如果数据个数是奇数，就取后 n/2 的数据的最小的数。
那么我们就可以使用一个最大堆和一个最小堆。用一个最大堆来维护当前前n/2小的元素，用一个最小堆来维护当前后n/2大的元素。
由于数据是实时插入的，
当插入的数据量是偶数时：则把新数据插入最小堆，如果插入的数比最大堆的堆顶元素小，则先把新数据插入最大堆，然后把最大堆的最大值（堆顶元素）插入最小堆。
当插入的数据量是奇数时：则把新数据插入最大堆，如果插入的数比最小堆的堆顶元素大，则先把新数据插入最小堆，然后把最小堆的最小值（堆顶元素）插入最大堆。
最后：数量为奇数时，取最小堆的堆顶元素。数量为偶数时，取最大堆和最小堆的两个堆顶元素的均值。

class Solution {
private:
    vector<int>min;
    vector<int>max;
public:
    void Insert(int num)
    {
        if( ((min.size() + max.size()) & 1) == 0)
        {
            if(max.size() > 0 && num < max[0])
            {
                max.push_back(num);
                push_heap(max.begin(), max.end(), less<int>());
                num = max[0];
                pop_heap(max.begin(), max.end(), less<int>());
                max.pop_back();
            }
            min.push_back(num);
            push_heap(min.begin(), min.end(), greater<int>());
        }
        else
        {
            if(min.size()>0 && num > min[0])
            {
                min.push_back(num);
                push_heap(min.begin(), min.end(), greater<int>());
                num = min[0];
                pop_heap(min.begin(), min.end(), greater<int>());
                min.pop_back();
            }
            max.push_back(num);
            push_heap(max.begin(), max.end(), less<int>());
        }
    }

    double GetMedian()
    { 
        int size = min.size()  + max.size();
        if(size == 0)
        {
            return -1;
        }
        double median;
        if((size & 1) == 1)
            median = (double)min[0];
        else
            median = (double)(max[0] + min[0]) / 2;
        return median;
    
    }

};

使用 priority_queue 的写法：

class Solution {
priority_queue<int, vector<int>, less<int> >Max;
priority_queue<int, vector<int>, greater<int> >Min;
public:
    void insert(int num){
        int maxlen = Max.size();
        int minlen = Min.size();
        
        if(maxlen == 0 && minlen == 0)
            Min.push(num);
        
        else if((maxlen+minlen)%2==1)
        {
            if(num > Min.top())
            {
                int a = Min.top();
                Min.pop();
                Min.push(num);
                Max.push(a);
            }
            else
            {
                Max.push(num);
            }
        }
        else
        {
            if(num < Max.top())
            {
                int a = Max.top();
                Max.pop();
                Max.push(num);
                Min.push(a);
            }
            else
            {
                Min.push(num);
            }
        }
        
    }

    double getMedian(){
        int  maxlen = Max.size();
        int minlen = Min.size();
        if((maxlen + minlen) %2 ==0)
        {
            return (double)(Max.top()+Min.top())/2;
        }
        else
        {
            return (double)(Min.top());
        }
        
    }
};