LeetCode 480. Sliding Window Median(java)

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

Examples:
[2,3,4] , the median is 3

[2,3], the median is (2 + 3) / 2 = 2.5

Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Your job is to output the median array for each window in the original array.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

Window position                Median
---------------               -----
[1  3  -1] -3  5  3  6  7       1
 1 [3  -1  -3] 5  3  6  7       -1
 1  3 [-1  -3  5] 3  6  7       -1
 1  3  -1 [-3  5  3] 6  7       3
 1  3  -1  -3 [5  3  6] 7       5
 1  3  -1  -3  5 [3  6  7]      6
Therefore, return the median sliding window as [1,-1,-1,3,5,6].

Note: 
You may assume k is always valid, ie: k is always smaller than input array's size for non-empty array.

思路和LC 295. Find Median from Data Stream几乎一致，我们通过maintain两个treemap（priorityqueue）来储存中位数，然后每次往后走都更新一下两个heap，分情况讨论。但是要注意：如果用（o1 - o2）这种自己写comparator的方法会有溢出的情况，当出现Integer.MAX_VALUE，因为comparator是根据减法来的，所以我们最好使用treemap自带的排序，反着的我们就reverse一下。

public double[] medianSlidingWindow(int[] nums, int k) {
        //special case 
        if (nums.length == 0) return new double[]{};
        if (k > nums.length) k = nums.length;
        if (k == 1) {
            double[] res = new double[nums.length];
            for (int i = 0; i < nums.length; i++) {
                res[i] = (double)nums[i];
            }
            return res;
        }
        //base case

        int[] cur = new int[k];
        for (int i = 0; i < k; i++) {
            cur[i] = nums[i];
        }
        Arrays.sort(cur);
        for (int i = 0; i < k / 2; i++) {
            maxHeap.add(cur[i]);
        }
        for (int i = k / 2; i < k; i++) {
            minHeap.add(cur[i]);
        }
        double[] res = new double[nums.length - k + 1];
        if (maxHeap.size() == minHeap.size()) {
                res[0] = ((double)maxHeap.peek() + (double)minHeap.peek()) / 2.0;
        } else {
                res[0] = (double)minHeap.peek();
        }
        //general case
        for (int i = k; i < nums.length; i++) {
            minHeap.add(nums[i]);
            if (minHeap.remove(nums[i - k])) {
                if (minHeap.peek() < maxHeap.peek()) {
                    minHeap.add(maxHeap.remove());
                    maxHeap.add(minHeap.remove());
                }
            } else {
                maxHeap.remove(nums[i - k]);
                maxHeap.add(minHeap.remove());
            }
            if (maxHeap.size() == minHeap.size()) {
                res[i - k + 1] = ((double)maxHeap.peek() + (double)minHeap.peek()) / 2.0;
            } else {
                res[i - k + 1] = (double)minHeap.peek();
            }
        }
        return res;
    }