480. 滑动窗口中位数

最后更新：2024-05-10-22

链接：https://leetcode.cn/problems/sliding-window-median/description/

题目描述

中位数是有序序列最中间的那个数。如果序列的长度是偶数，则没有最中间的数；此时中位数是最中间的两个数的平均数。

例如：

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

给你一个数组 nums，有一个长度为 k 的窗口从最左端滑动到最右端。窗口中有 k 个数，每次窗口向右移动 1 位。你的任务是找出每次窗口移动后得到的新窗口中元素的中位数，并输出由它们组成的数组。

题目示例

示例 1：

给出 nums = [1,3,-1,-3,5,3,6,7]，以及 k = 3。

窗口位置                      中位数
---------------               -----
[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

因此，返回该滑动窗口的中位数数组 [1,-1,-1,3,5,6]。

提示：

• 你可以假设 k 始终有效，即：k 始终小于等于输入的非空数组的元素个数。
• 与真实值误差在 \(10^{-5}\) 以内的答案将被视作正确答案。

解题思路

1. K = 1，这里返回的是double，不能直接memcpy，或者直接返回nums，要做特殊处理
2. numsSize < K的场景，直接进行排序，获取中位数就可以。
3. 其他场景：
   1. 维护一个数组，数组大小为K， 先存储nums[0]~nums[k]的值,并且做下从小到大的排序，当然降序也可以
   2. 因为我们是有序的数组，所以每次使用二分法去查找要out的数值，然后剔除，数值后面的往前移动
   3. 再使用二分法，找到新数值in要插入的位置，插入后，后面的数据位置后移，注意这里因为前面已经移除了一个数值，这里实际的有效数值个数是k-1个。
   4. 得到新的数组就是新的滑动窗口中的所有数值，并且已经排序好的，直接获取中位数即可。

CGo

#define MAX_NUMS_LEN 10000

int comp(const void *a, const void *b)
{
    if (*(int*)a > *(int*)b) {
        return 1;
    }

    return -1;
}

double getMedianNum(const int* nums, int k)
{
    int mid = 0;
    double ans = 0;

    // k为奇数，取k-1/2位置的值
    if ((k % 2) == 1) {
        mid = (k - 1) / 2;
        ans = nums[mid];
    } else {
        // k 为偶数，取k/2 -1 和k/2的值求平均
        mid = k / 2;
        ans = (nums[mid - 1] / 2.0) + (nums[mid] / 2.0);
    }

    return ans;
}

int findKeyOutPos(const int* nums, int key, int low, int high)
{
    int mid = 0;

    if (nums[low] == key) {
        return low;
    }

    if (nums[high] == key) {
        return high;
    }

    mid = (low + high) / 2;
    if (nums[mid] > key) {
        return findKeyOutPos(nums, key, mid, high - 1);
    } else {
        return findKeyOutPos(nums, key, low + 1, mid);
    }
}

int findKeyInPos(int* nums, int numsSize, int key, int low, int high)
{
    int mid = 0;
    mid = (low + high) / 2;
    if (nums[mid] >= key) {
        // 到0了；
        if (mid < 1) {
            return mid;
        }
        if (nums[mid - 1] <= key) {
            // 插入到mid位置，mid的数据后移
            return mid;
        }
        return findKeyInPos(nums, numsSize, key, low, mid - 1);
    } else {
        // 到最大了
        if (mid + 1 >= numsSize) {
            return mid + 1;
        }

        if (nums[mid + 1] >= key) {
            // 插入到mid + 1位置，mid的数据后移
            return mid + 1;
        }
        return findKeyInPos(nums, numsSize, key, mid + 1, high);
    }
}

void slidingWindowOut(int* nums, int numsSize, int num)
{
    int winOut, i;
    winOut = findKeyOutPos(nums, num, 0, numsSize - 1);
    if (winOut == (numsSize - 1)) {
        return;
    }

    for (i = winOut + 1; i < numsSize; i++) {
        nums[i - 1] = nums[i];
    }
}

void slidingWindowIn(int* nums, int numsSize, int num)
{
    int winIn, i, pre, tmp;
    // 已经出去了一个值，这里nums就只有numsSize - 1个值了，数组还是有numsSize大小
    winIn = findKeyInPos(nums, numsSize - 1, num, 0, numsSize - 2);
    if (winIn == (numsSize - 1)) {
        nums[numsSize - 1] = num;
        return;
    }

    pre = nums[winIn];
    nums[winIn] = num;
    for (i = winIn + 1; i < numsSize; i++) {
        tmp = nums[i];
        nums[i] = pre;
        pre = tmp;
    }
}

double* medianSlidingWindow(int* nums, int numsSize, int k, int* returnSize)
{
    double *result = NULL;
    int i;
    int tmp[MAX_NUMS_LEN] = {0};

    result = (double*)malloc(sizeof(double) * MAX_NUMS_LEN);
    (void)memset(result, 0, sizeof(double) * MAX_NUMS_LEN);

    if (k == 1) {
        result = (double*)malloc(sizeof(double) * numsSize);
        (void)memset(result, 0, sizeof(double) * numsSize);
        *returnSize = numsSize;
        for (i = 0; i < *returnSize; i++) {
            result[i] = nums[i];
        }
        return result;
    }

    // 只有一个滑动窗口
    if (numsSize <= k) {
        result = (double*)malloc(sizeof(double) * 2);
        (void)memset(result, 0, sizeof(double) * 2);
        *returnSize = 1;
        qsort(nums, numsSize, sizeof(int), comp);
        result[0] = getMedianNum(nums, k);
        return result;
    }

    // 多个滑动窗口
    result = (double*)malloc(sizeof(double) * MAX_NUMS_LEN);
    (void)memset(result, 0, sizeof(double) * MAX_NUMS_LEN);
    (void)memset(tmp, 0, sizeof(int) * MAX_NUMS_LEN);
    memcpy(tmp, nums, k * sizeof(int));
    qsort(tmp, k, sizeof(int), comp);
    result[0] = getMedianNum(tmp, k);
    *returnSize = numsSize - k + 1;
    for (i = 1; i < *returnSize; i++) {
        slidingWindowOut(tmp, k, nums[i - 1]);
        slidingWindowIn(tmp, k, nums[i + k - 1]);
        result[i] =  getMedianNum(tmp, k);
    }

    return result;
}