LeetCode 480. Sliding Window Median(java)_480. sliding window median java-CSDN博客

本文介绍了一种计算滑动窗口中位数的有效算法。该算法通过维护两个堆（最大堆和最小堆），实现对窗口内数据的快速排序及中位数查找，解决了数组中滑动窗口中位数的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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;
    }