LeetCode 295. 数据流的中位数 [设计一种高效的数据结构计算动态集合的中位数]

如题：

---

一、首次解题思路：

使用一个容器存放输入的数据，每加入一个数字，就对列表进行排序，根据下标找出中位数。

二、思路一代码实现：

class MedianFinder {
    vector<int> v;
public:
    MedianFinder() {

    }
    
    void addNum(int num) {
        v.push_back(num);
        sort(v.begin(), v.end());
    }
    
    double findMedian() {
        if (v.size() % 2) {
            return v[v.size() / 2];
        } else {
            return (v[v.size() / 2 - 1] + v[v.size() / 2]) / 2.0;
        }
    }
};

三、思路一运行结果：

哦豁， 我就知道一道困难题怎么会这么容易，sort 的时间复杂度为 O(nlogn), 估计时间复杂度得在 O(log n) 级, 不能有 n。

---

四、二次解题思路：

利用二叉搜索树并维护每个节点及其子节点的个数size，不需要考虑排序问题，寻找中位数时通过size检索，但是二叉搜索树受限平衡性，时间复杂度平均O(log n), 最差情况是二叉树元素都在一边，复杂度为 O(n)。

---

五、思路二代码实现：

// 建立二叉搜索树的数据结构
struct BSTreeNode {
    int val;
    int size;
    BSTreeNode *left;
    BSTreeNode *right;
    // 构造函数
    BSTreeNode(int v) :val(v), size(1),left(NULL),right(NULL) {}
};


class MedianFinder {

private:
    BSTreeNode *root;

public:
    MedianFinder() :root(NULL) {}
    
    void addNum(int num) {
        if (this->root == NULL) {
            root = new BSTreeNode(num);
        } else {
            addNum_(num, root);
        }
    }

    void addNum_(int num, BSTreeNode *node) {
        if (node->val >= num) {
            if (node->left == NULL) {
                node->left = new BSTreeNode(num);
            } else {
                addNum_(num, node->left);
            }
        } else {
            if (node->right == NULL) {
                node->right = new BSTreeNode(num);
            } else {
                addNum_(num, node->right);
            }
        }
        node->size++;
    }

    int search(int index, BSTreeNode *node) {
        if (node->size == 1) {
            return node->val;
        }
        int leftSize = node->left != nullptr ? node->left->size : 0;
        if (leftSize >= index) {
            return search(index, node->left);
        } else if (leftSize + 1 == index) {
			return node->val;
		} else {
            return search(index - leftSize - 1, node->right);
        }
    }
    
    double findMedian() {
    		// 奇数个
        if (this->root->size % 2) {
            return search(this->root->size / 2 + 1, this->root);
        } else {
        	// 偶数个
            int left = search(this->root->size / 2, this->root);
            int right = search(this->root->size / 2 + 1, this->root);
            return (left + right) / 2.0;
        }
    }
};

---

六、思路二运行结果：

很遗憾，TLE，比上一思路多运行了两个测试样例 , 有部分测试用例导致二分搜索树退化成链表了，时间复杂度到了最坏的情况 O(n)

---

七、三次解题思路：

构建平衡二叉树，search 和上面搜索二叉树一样，时间复杂度能保持在 O(log n), 后续补上代码

---

八、四次解题思路：

构建两个优先队列，使用两个优先队列（堆）来维护整个数据流数据，令维护数据流左半边数据的优先队列（堆）为 l，维护数据流右半边数据的优先队列（堆）为 r。

显然，为了可以在 O(1) 的复杂度内取得当前中位数，我们应当令 l 为大根堆，r 为小根堆，并人为固定 l 和 r 之前存在如下的大小关系：

• 当数据流元素数量为偶数：l 和 r 大小相同，此时中位数为两者堆顶元素的平均值；
• 当数据流元素数量为奇数：l 比 r 多一，此时中位数为 l 的堆顶。

为了满足上述说的奇偶性堆大小关系，在进行 addNum 时，我们应当分情况处理：

插入前检查两堆元素个数相同，则插入前数据流元素个数为偶数，插入后变为奇数。我们期望操作完达到「l 的数量为 r 多一，同时双堆维持有序」，进一步分情况讨论：

• 如果 r 为空，说明当前插入的是首个元素，直接添加到 l 即可。
• 如果 r 不为空，且 num <= r.top()，说明 num 的插入位置不会在 r 中，直接加到 l 即可。
• 如果 r 不为空，且 num > r.top()，说明 num 的插入位置在r中，此时将 r 的堆顶元素放到 l 中，再把 num 放到 r（相当于从 r 中置换一位出来放到 l 中）。

插入前两者大小不同，说明前数据流元素个数为奇数，插入后变为偶数。我们期望操作完达到「l 和 r 数量相等，同时双堆维持有序」，进一步分情况讨论（此时 l 必然比 r 元素多一）

• 如果 num >= l.top()，说明 num 的插入位置不会在 l 中），直接添加到 r 即可。
• 如果 num < l.top()，说明 num 的插入位置在 l 中，此时将 l 的堆顶元素放到 r 中，再把 num 放入 l 中（相等于从 l 中替换一位出来当到 r 中。

---

八、思路四实现代码：

class MedianFinder {
    priority_queue <int,vector<int>,less<int> > l; // 大顶堆 
    priority_queue <int,vector<int>,greater<int> > r; // 小顶堆
public:
    MedianFinder() {

    }
    
    void addNum(int num) {
        int sl = l.size(); int sr = r.size();
        // 如果插入前 l 和 r 元素个数相同，说明是偶数，再加一个就是奇数了
        if (sl == sr) {
            if (r.empty() || num <= r.top()) {
                l.push(num);
            } else {
                int v = r.top(); r.pop();
                l.push(v);
                r.push(num);
            }
        } else {
            // 如果原来为奇数，再加一个就是偶数了
            if (l.top() <= num) {
                r.push(num);
            } else {
                int v = l.top(); l.pop();
                r.push(v);
                l.push(num);
            }
        }
    }
    
    double findMedian() {
        int sl = l.size(); int sr = r.size();
        if (sl == sr) {
            return (l.top() + r.top()) / 2.0;
        } else {
            return l.top();
        }
    }
};

九、 思路四运行结果：

时间复杂度为 O(log⁡n)