295. Find Median from Data Stream

The median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value and the median is the mean of the two middle values.

• For example, for arr = [2,3,4], the median is 3.
• For example, for arr = [2,3], the median is (2 + 3) / 2 = 2.5.

Implement the MedianFinder class:

• MedianFinder() initializes the MedianFinder object.
• void addNum(int num) adds the integer num from the data stream to the data structure.
• double findMedian() returns the median of all elements so far. Answers within 10-5 of the actual answer will be accepted.

Example 1:

Input
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
Output
[null, null, null, 1.5, null, 2.0]

Explanation
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1);    // arr = [1]
medianFinder.addNum(2);    // arr = [1, 2]
medianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2)
medianFinder.addNum(3);    // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

Constraints:

• -105 <= num <= 105
• There will be at least one element in the data structure before calling findMedian.
• At most 5 * 104 calls will be made to addNum and findMedian.

题目要求以数据流的形式往数据结构中存储整型数据，并可以实时访问所有数据的中位数。一看到“中位数”自然想到排序，并且要求实时排序，也就是数据结构需要变长的。

方法一：用vector。因为需要排序，需要中位数位置（可以快速指定中间位置的数值），且可变长，首先想到vector。代码如下：

class MedianFinder {
private:
    vector<int> nums;
public:
    MedianFinder() {
        while(nums.size() > 0) nums.pop_back();
    }
    
    void addNum(int num) {
        if(nums.size() == 0 || num > nums.back()) 
            nums.push_back(num);
        else {
            auto it = lower_bound(nums.begin(), nums.end(), num);
            nums.insert(it, num);
        }
    }
    
    double findMedian() {
        int size = nums.size();
        if(size % 2 == 0){
            return double(nums[size/2] + nums[size/2-1]) / 2.0;
        } else 
            return nums[size/2];
    }
};

但是！在vector中变长，只有在末尾push_back进数值时间复杂度才可能为O(1)，在中间插入数值的话，时间复杂度为O（n）,n为数组长度。因此，用vector超时了。

方法二，还有什么数据结构又能排序又能变长呢？priority_queue, set, map都可以。这里用priority_queue，因为pop和push都很容易。需要指定中位数，因此用两个priority_queue，维护一个大顶堆，一个小顶堆。用来存储数组中数值小的一半和数值大的一半。代码如下：

class MedianFinder {
private:
    priority_queue<int, vector<int>, greater<int>> minQ;
    priority_queue<int> maxQ;
public:
    MedianFinder() {
    }
    
    void addNum(int num) {
        if(minQ.empty() || num > minQ.top()){
            minQ.push(num);
            if(minQ.size() > maxQ.size()+1){
                maxQ.push(minQ.top());
                minQ.pop();
            }
        } else {
            maxQ.push(num);
            if(maxQ.size() > minQ.size()+1){
                minQ.push(maxQ.top());
                maxQ.pop();
            }
        }
    }
    
    double findMedian() {
        if(minQ.size() == maxQ.size()){
            return double(minQ.top() + maxQ.top()) / 2.0;
        } else if(minQ.size() > maxQ.size())
            return minQ.top();
        else return maxQ.top();
    }
};