leetcode面试题41. 数据流中的中位数(同leetcode295. 数据流的中位数)

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

例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5

设计一个支持以下两种操作的数据结构：
void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
示例 1：

输入：
[“MedianFinder”,“addNum”,“addNum”,“findMedian”,“addNum”,“findMedian”]
[[],[1],[2],[],[3],[]]
输出：[null,null,null,1.50000,null,2.00000]
示例 2：

输入：
[“MedianFinder”,“addNum”,“findMedian”,“addNum”,“findMedian”]
[[],[2],[],[3],[]]
输出：[null,null,2.00000,null,2.50000]

限制：

最多会对 addNum、findMedia进行 50000 次调用。

我的想法，首先是有序，然后要快速查找，那就是用TreeSet和链表的结合，自己设计一个链表
解答代码如下：

class MedianFinder {

    private int deep;
	//中间节点，如果节点数为奇数，就是中间节点，如果节点数是偶数，为中间节点的左节点
    private Node currentNode;
    TreeSet<Node> tree;

    public MedianFinder() {
        deep = 0;
        tree = new TreeSet<>();
    }

    private void init(Node node) {
		//第一个节点，不用太复杂
        tree.add(node);
        currentNode = node;
    }

    public void addNum(int num) {
        Node node = new Node(num);
        deep++;
        if (deep == 1) {
            init(node);
            return;
        }
		//找到tree中要插入的左节点
        Node left = tree.floor(node);
        if (left == null) {
			//没有左节点设置成首节点
            Node first = tree.first();
			first.pre = node;
            node.next = first;
        } else {
			//插入链表
            Node right = left.next;
            if (right != null) {
                right.pre = node;
                node.next = right;
            }
            left.next = node;
            node.pre = left;
        }
		//插入树
        tree.add(node);
		//移动中间节点的位置
        if (deep % 2 == 1 && node.compareTo(currentNode) > 0) {
            currentNode = currentNode.next;
        } else if (deep % 2 == 0 && node.compareTo(currentNode) < 0) {
            currentNode = currentNode.pre;
        }
    }

    public double findMedian() {
        if (deep % 2 == 1) {
			//节点数为奇数时，就是中间节点的值
            return currentNode.value;
        } else {
			//节点数为偶数时，为两个节点的平均值
            return (0.0 + currentNode.value + currentNode.next.value) / 2;
        }

    }
}

class Node implements Comparable {
    int value;
    Node pre;
    Node next;

    public Node(int num) {
        this.value = num;
    }

    @Override
    public int compareTo(Object o) {
        Node n2 = (Node) o;
        if (this.value == n2.value) {
			//防止冲突
            return this.hashCode() - n2.hashCode();
        }
        return this.value - n2.value;
    }

}