剑指Offer-数据结构 59 - I. 滑动窗口的最大值

最新推荐文章于 2025-01-08 16:39:02 发布

原创最新推荐文章于 2025-01-08 16:39:02 发布 · 373 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

剑指Offer

这篇博客讨论了如何在给定数组和窗口大小k的情况下找到滑动窗口的最大值。提出了四种方法：暴力遍历、单调队列、优先队列和分块处理，重点介绍了单调队列作为优化手段，以降低时间复杂度。

剑指Offer-数据结构 59 - I. 滑动窗口的最大值

Q：给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:

滑动窗口的位置最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
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 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

先分析一下什么滑动窗口的逻辑：

假设数组为nums，假设窗口区间是 $[i, j]$ ,则最大值为 $x$ , 当窗口前进一格，区间就变成 $[i+1, j+1]$ , 即每次移动就是添加元素 $nums[j+1]，$ ，删除 $nums[i]$ 。

要获取窗口的最大值，直接遍历区间取出最大值即可:

$x = max(nums[i+1]+...+nums[j+1])$

1、窗口内遍历获取最大值，线性遍历，时间复杂度： $O(k)$ 。

2、数组nums长度是n,窗口数量是多少呢？

假设n = 6, 可以得出：

n k 窗口数

6 1 6

6 2 5

6 3 4

6 4 3

6 5 2

可以很容易看出规律： n - k + 1就等于窗口数量。

所以时间复杂度就变成了： $O((n-k+1) k)$

据此我们已经可以写出代码了：

方法一：暴力遍历法：

//输入的是连续地址的数组区间指针
int max(int *start, int *end) {
    printf("%x, %x", start, end);
    printf("\nsliding: [%d - %d]\n", *start, *end);
    int max = *start;
    //连续数组才能使用该方法判断
    while(start <= end) {
        if (*start > max) {
            max = *start;
        }
        start++;
    }
    printf("max: %d\n", max);
    return max;
}

int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
    int size = numsSize - k +1;
    int *res = (int *)malloc(sizeof(int) * (size));
    int *p = res;
    int i;
    for (i = 0; i < size; i++) {
        *p++ = max(nums+i, nums+(i+k-1));
    }
    *returnSize = size;
    return res;
}

int main() {
    int returnSize;
    int nums[] = {1,3,-1,-3,5,3,6,7};
    int *ret = maxSlidingWindow(nums, sizeof(nums)/sizeof(int), 3, &returnSize);
    int i;
    for (i = 0; i < returnSize; i++) {
        printf(" %d , ", *(ret+i));
    }

    return 0;
}

这个比较简单，很容易就可以写出实现，但是有没有优化空间呢？上面的时间复杂度 $O((n-k+1) k)$ , 约为 $O(nk)$ , 前面的窗口数无法优化，但是在窗口内查找最大值，这个可以优化，因为每次移动值会变化一个数。那如何可以将 $O(k)$ 降为 $O(1)$ 呢？说白了就是实现一个最大优先队列，保证每次从窗口内查找最大值可以将时间复杂度降为 $O(1)$ 。

方法二：单调队列

我们可以使用和《剑指Offer-数据结构 30. 包含 min 函数的栈》同样的处理办法，窗口对应的数据是双端队列，有数据从列表首部删除，同时有数据从尾部进入，我们可以借助一个单调队列：

1、队列内只包含窗口内的元素，窗口移动的时候移除的元素在这个单调队列内同样移除。

2、单调队列元素非严格递减，每次窗口移动添加元素后，需将单调队列内所有小于这个新入数据的元素移除，保证这个单调队列的单调性。

eg：1,3,-1,-3,5,3,6,7

初始化时单调队列为空。

第1个数1入单调队列[0]

第2个数3大于队列中已有的数据，pop出比3小的数据序号，再添加，单调队列就变成了[1]

第3个数-1，重复上面的过程，找到比-1小的数据pop出去，这里没有，就直接添加，单调队列就变成了[1,2]

第4个数-3，找到比其小的数据pop出去，这里没有，直接添加，单调队列就变成了[1,2,3]

第5个数5，找到比其小的数据pop出去，这里需要全部pop出去，单调队列就变成了[4]

第6个数3，找到比其小的数据pop出去，这里没有，直接添加，单调队列就变成了[4,5]

第7个数-6，找到比其小的数据pop出去，这里需要全部pop出去，单调队列就变成了[6]

第8个数7，找到比其小的数据pop出去，这里需要全部pop出去，单调队列就变成了[7]

需要注意，这里模拟的双端单调队列，队列头部和尾部有g_left,g_right控制的，pop一个数据并不是真的从队列的实现数组中移除，而是利用一个g_left标志指针确定队列头。

#define QUEMAX    (10000)
typedef struct _Node {
    int i;      // 记录数据的索引
    int value;  // 记录数据的值
}Node;

Node g_que[QUEMAX] = {0};
int g_left = 0;      // 队列的左指针
int g_right = 0;     // 队列的右指针

Node *GetTail() // 获取队尾
{
    int right;
    if (g_left == g_right) {
        return NULL;
    }

    right = (g_right - 1 + QUEMAX) % QUEMAX;
    return &g_que[right];
}

Node *GetHead()  // 获取队头
{
    if (g_left == g_right) {
        return NULL;
    }
    return &g_que[g_left];
}

Node *PopTail()  // 弹出队尾
{
    if (g_left == g_right) {
        return NULL;
    }

    g_right = (g_right - 1 + QUEMAX) % QUEMAX;
    return &g_que[g_right];
}

Node *PopHead() // 弹出队头
{
    int left;
    if (g_left == g_right) {
        return NULL;
    }

    left = g_left;
    g_left = (g_left + 1) % QUEMAX;

    return &g_que[left];
}

void PushTail(int i, int num) // 从队尾入队列
{
    Node *tail;

    tail = GetTail();

    while (tail != NULL && num > tail->value) { // 实现单调递减队列，队头一定是最大值
        PopTail();
        tail = GetTail();
    }

    g_que[g_right].i = i;
    g_que[g_right].value = num;
    g_right = (g_right + 1) % QUEMAX;
}

void displayGQue() {
    Node *head = GetHead();
    if(head != NULL) {
        printf("que head: %d, value: %d \n", head->i, head->value);
    }
    int i;
    printf("g_que: [ ");
    for (i = g_left; i < g_right; i++){
        printf(" %d ",  g_que[i].i);
    }
    printf(" ]\n\n");
}


int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize){
    int i;
    Node *node;
    int *r;
    int rn = 0;


    g_left = g_right = 0;
    r = malloc(sizeof(int) * (numsSize - k + 1));

    displayGQue();
    for (i = 0; i < k; i++) {
        PushTail(i, nums[i]);
    }
    displayGQue();
    node = GetHead();
    r[rn++] = node->value;

    for (i = k; i < numsSize; i++) {
        node = GetHead();
        if (i - k == node->i) { // 每次移除的数如果是队头，就从单调队列移除队头
            printf("POP head [i(%d)-k(%d)] == %d\n", i, k, node->i);
            PopHead();
        }
        PushTail(i, nums[i]);  // 继续入队列
        node = GetHead();      // 从队头获取当前队列的最大值
        r[rn++] = node->value;

        displayGQue();
    }

    *returnSize = rn;
    return r;
}



int main() {
    int returnSize;
    int nums[] = {1,3,-1,-3,5,3,6,7};
    int *ret = maxSlidingWindow(nums, sizeof(nums)/sizeof(int), 3, &returnSize);
    int i;
    for (i = 0; i < returnSize; i++) {
        printf(" %d , ", *(ret+i));
    }
    return 0;
}

输出：

g_que: [  ]

que head: 1, value: 3 
g_que: [  1  2  ]

que head: 1, value: 3 
g_que: [  1  2  3  ]

POP head [i(4)-k(3)] == 1
que head: 4, value: 5 
g_que: [  4  ]

que head: 4, value: 5 
g_que: [  4  5  ]

que head: 6, value: 6 
g_que: [  6  ]

que head: 7, value: 7 
g_que: [  7  ]

 3 ,  3 ,  5 ,  5 ,  6 ,  7