LeetCode 295 做题记录

题目：295. 数据流的中位数

链接：https://leetcode-cn.com/problems/find-median-from-data-stream/

题目描述：

看到这个题目第一反应，排序就行了嘛！下面直接用排序写：

public class MedianFinder {
    int[] arr;
    int length;

    public MedianFinder() {
        arr = new int[100000];
        length = 0;
    }

    public void addNum(int num) {
        arr[length ++] = num;
    }

    public double findMedian() {
        Arrays.sort(arr, 0, length);
//        int[] arrs = Arrays.copyOf(arr, length);
//        Arrays.sort(arrs);
        if (length == 0) return 0;
        if (length % 2 == 0) {
            return (arr[(length - 1) / 2] + arr[(length - 1) / 2 + 1]) / 2.0;
        }
        return arr[length / 2];
    }

时间复杂度 nlog(n)

优化方法：每次插入使用二分查找再插入的方法，代码如下：

    public void addNum(int num) {
        if (length == 0) {
            arr[0] = num;
            length ++;
            return;
        }
        int left = 0;
        int right = length - 1;
        int mid = 0;
        while (left <= right) {
            mid = (right + left) / 2;
            if (arr[mid] == num) {
                break;
            } else if (arr[mid] > num) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        if (arr[mid] > num) {
//            mid--;
        } else if (arr[mid] < num) {
            mid ++;
        }
        for (int i = length; i > mid; i--) {
            try {
                arr[i] = arr[i - 1];
            } catch (ArrayIndexOutOfBoundsException e) {

            }
        }
        arr[mid == -1 ? 0 : mid] = num;
        length ++;
    }

    public double findMedian() {
        if (length == 0) return 0;
        if (length % 2 == 0) {
            return (arr[(length - 1) / 2] + arr[(length - 1) / 2 + 1]) / 2.0;
        }
        return arr[length / 2];
    }

找到插入位置特别麻烦，边界条件太多，代码不优雅。

使用二分查找的变种，直接寻找大于等于插入值的值在数组的位置，直接插入。

关于二分查找的变形可以看这个兄弟的博客：https://www.cnblogs.com/kyoner/p/11080078.html

这个算法很难记住，但从left<right，可以判断想要跳出循环，left就要步步逼近，left++，其余的要理解。

代码如下：

/**
     * 插入排序改进
     * @param num
     */
    public void addNum(int num) {
        int left = 0;
        int right = length;
        int mid = 0;
        // 求左边界
        while (left < right) {
            mid = (right + left) / 2;
            if (arr[mid] == num) {
                right = mid;
            } else if (arr[mid] > num) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        mid = left;
        for (int i = length; i > mid; i--) {
            arr[i] = arr[i - 1];
        }
        arr[mid == -1 ? 0 : mid] = num;
        length ++;
    }

    public double findMedian() {
        if (length == 0) return 0;
        if (length % 2 == 0) {
            return (arr[(length - 1) / 2] + arr[(length - 1) / 2 + 1]) / 2.0;
        }
        return arr[length / 2];
    }

这样写清晰多了

还有另一种解法：使用Java优先级队列（直接使用堆排序也可解）

    PriorityQueue<Integer> maxQueue;
    PriorityQueue<Integer> minQueue;
    int count;

    /** initialize your data structure here. */
    public MedianFinder() {
        maxQueue = new PriorityQueue<>((x, y) -> y - x);
        minQueue = new PriorityQueue<>();
        count = 0;
    }

    public void addNum(int num) {
        count ++;
        maxQueue.add(num);
        minQueue.add(maxQueue.poll());
        if ((count & 1) != 0) {
            maxQueue.add(minQueue.poll());
        }
    }

    public double findMedian() {
        if ((count & 1) == 0) {
            return (maxQueue.peek() + minQueue.peek()) / 2.0;
        } else {
            return maxQueue.peek();
        }
    }

over!!!