算法---LeetCode 295. 数据流的中位数(同剑指 Offer 41)

1. 题目

原题链接
剑指offer链接

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数
值排序之后中间两个数的平均值。
例如，
[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、findMedian 进行 50000 次调用。

2. 题解

2.1 解法1: 优先队列 (堆)

思路

使用 小顶堆 A和大顶堆 B分别保存数据的一半, A保存较大的一半, B保存较小的一半, 这样需要中位数时, 根据数据总数弹出 A,B的堆顶即可, 左大顶, 右小顶

流程

添加数字时, 设 A ,B中元素个数分别为 m, n

1. 若 m=n, 此时添加元素到小顶堆A, 但具体操作时, 先将元素加入 B 中, 再将B的堆顶元素加入A
2. 若 m!=n, 此时添加元素到 B, 但具体操作时, 先将元素加入 A 中, 再将B的堆顶元素加入B

    class MedianFinder {

        PriorityQueue<Integer> A;
        PriorityQueue<Integer> B;

        /**
         * initialize your data structure here.
         */
        public MedianFinder() {
            A = new PriorityQueue<>();
            B = new PriorityQueue<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2 - o1;
                }
            });
        }

        public void addNum(int num) {
            int m = A.size();
            int n = B.size();
            if (m == n) {
                B.offer(num);
                A.offer(B.poll());
            } else {
                A.offer(num);
                B.offer(A.poll());
            }
        }

        public double findMedian() {
            if (A.size() == B.size()) {
                return (A.peek() + B.peek()) / 2.0;
            } else {
                return A.peek();
            }
        }
    }

参考:
面试题41. 数据流中的中位数（优先队列 / 堆，清晰图解）

2.2 解法 2: 简单排序

在需要返回中位数时队集合进行排序, 计算中位数

    class MedianFinder {
        List<Integer> list;

        /**
         * initialize your data structure here.
         */
        public MedianFinder() {
            list = new ArrayList<>();
        }

        public void addNum(int num) {
            list.add(num);
        }

        public double findMedian() {
            Collections.sort(list);
            int n = list.size();
            if (n % 2 == 1) {
                return list.get(n / 2);
            } else {
                return (list.get(n / 2) + list.get(n / 2 - 1)) / 2.0;
            }

        }

    }

时间复杂度: O(nlogn)

2.3解法 3: 插入排序

保持集合中元素有序, 在 addNum() 插入元素时使用插入排序, 寻找第一个大于 num 的数的下标

    class MedianFinder {
        List<Integer> list;

        /**
         * initialize your data structure here.
         */
        public MedianFinder() {
            list = new ArrayList<>();
        }

        public void addNum(int num) {
            int n = list.size();
            int i = 0;
            // 寻找第一个大于 num 的数的下标
            for (; i < n; i++) {
                if (num < list.get(i)) {
                    break;
                }
            }
            list.add(i, num);
        }

        public double findMedian() {
            int n = list.size();
            if (n % 2 == 1) {
                return list.get(n / 2);
            } else {
                return (list.get(n / 2) + list.get(n / 2 - 1)) / 2.0;
            }

        }

    }

优化

在插入元素时, 由于原集合有序, 可以使用二分查找来找到第一个大于num的位置

注意点:

1. 二分查找寻找元素所有可能插入的位置, 注意条件判断时, 因为是寻找大于 num 下标的数的位置, 所以是 >=
2. 最后考虑list 为空, 有一个元素的情况, 进行特判

    class MedianFinder {
        List<Integer> list;

        /**
         * initialize your data structure here.
         */
        public MedianFinder() {
            list = new ArrayList<>();
        }

        public void addNum(int num) {
            int n = list.size();
            int left = 0, right = n - 1;
            // 寻找第一个大于 num 的数的下标, 可能插入的位置, 包含n
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (num >= list.get(mid)) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
            // 这里注意判断 0个元素和 1 个元素导致的特殊情况
            if (n == 0 || list.get(left) <= num) {
                list.add(num);
            } else {
                list.add(left, num);
            }
            System.out.println(1);
        }

        public double findMedian() {
            int n = list.size();
            if (n % 2 == 1) {
                return list.get(n / 2);
            } else {
                return (list.get(n / 2) + list.get(n / 2 - 1)) / 2.0;
            }

        }

    }

参考: 详细通俗的思路分析，多解法