《剑指offer》第四十一题：数据流中的中位数

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

#include <cstdio>
#include <algorithm>
#include <vector>
#include <functional>

using namespace std;

template<typename T> class DynamicArray
{
public:
    void Insert(T 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<T>());  //调整插入后的堆符合最大堆原则

                num = max[0];  //选出最大堆中最大值

                pop_heap(max.begin(), max.end(), less<T>());  //调整栈准备弹出最大值
                max.pop_back(); //弹出最大值
            }

            min.push_back(num);  //插入最小堆
            push_heap(min.begin(), min.end(), greater<T>());  //使得插入后的堆符合最小堆原则
        }
        else  //如果总个数为奇数, 则插入最大堆
        {
            //如果此值大于最大堆中最小值, 则应属于最小堆
            if (min.size() > 0 && num > min[0])
            {
                min.push_back(num);  //插入最小堆
                push_heap(min.begin(), min.end(), greater<T>());  //调整插入后的堆符合最小堆原则

                num = min[0];  //选出最小堆中最小值

                pop_heap(min.begin(), min.end(), greater<T>());  //调整栈准备弹出最小值
                min.pop_back(); //弹出最小值
            }

            max.push_back(num);
            push_heap(max.begin(), max.end(), less<T>());
        }
    }

    T GetMedian()  //得到数据的中位数
    {
        int size = min.size() + max.size();
        if (size == 0)
            throw exception("No numbers are available");

        T median = 0;
        if ((size & 1) == 1) //奇数, 则从最小堆中拿出最小值
            median = min[0];
        else
            median = (min[0] + max[0]) / 2;

        return median;
    }

private:
    //[最大堆] < [最小堆] 最小堆中最小值大于最大堆中最大值
    vector<T> min;  //假设这是一个最小堆, 表示数据的右半段
    vector<T> max;  //同样假设这是最大堆, 表示数据的左半段
};

// ====================测试代码====================
void Test(const char* testName, DynamicArray<double>& numbers, double expected)
{
    if (testName != nullptr)
        printf("%s begins: ", testName);

    if (abs(numbers.GetMedian() - expected) < 0.0000001)
        printf("Passed.
");
    else
        printf("FAILED.
");
}

int main(int argc, char* argv[])
{
    DynamicArray<double> numbers;

    printf("Test1 begins: ");
    try
    {
        numbers.GetMedian();
        printf("FAILED.
");
    }
    catch (const exception&)
    {
        printf("Passed.
");
    }

    numbers.Insert(5);
    Test("Test2", numbers, 5);

    numbers.Insert(2);
    Test("Test3", numbers, 3.5);

    numbers.Insert(3);
    Test("Test4", numbers, 3);

    numbers.Insert(4);
    Test("Test6", numbers, 3.5);

    numbers.Insert(1);
    Test("Test5", numbers, 3);

    numbers.Insert(6);
    Test("Test7", numbers, 3.5);

    numbers.Insert(7);
    Test("Test8", numbers, 4);

    numbers.Insert(0);
    Test("Test9", numbers, 3.5);

    numbers.Insert(8);
    Test("Test10", numbers, 4);

    return 0;
}

分析：分析多种算法的时间、空间复杂度。

class Solution {
private:
    vector<int> min;
    vector<int> max;
public:
    void Insert(int num)
    {
        int size = min.size() + max.size();
        if ((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 & 1) == 0)
            return (min[0] + max[0]) / 2.0;
        else
            return min[0];
    }
};