⭐算法入门⭐《队列 - 单调队列》困难01 —— LeetCode 239. 滑动窗口最大值

Posted 2021-09-06 英雄哪里出来

🙉饭不食，水不饮，题必须刷🙉
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
LeetCode 太难？先看简单题！ 🧡《C语言入门100例》🧡
数据结构难？不存在的！ 🌳《画解数据结构》🌳
LeetCode 太简单？算法学起来！ 🌌《夜深人静写算法》🌌

文章目录

• 一、题目
• • 1、题目描述
  • 2、基础框架
  • 3、原题链接
• 二、解题报告
• • 1、思路分析
  • 2、时间复杂度
  • 3、代码详解
• 三、本题小知识

一、题目

1、题目描述

  给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。
  样例输入： nums = [1,3,-1,-3,5,3,6,7], k = 3
  样例输出： [3,3,5,5,6,7]

2、基础框架

• C语言版本 给出的基础框架代码如下：

int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize){

}

• 注意，这里返回的是一个堆上的数组，用 malloc进行申请内存，函数调用方会负责对这块内存进行清理工作。
  

3、原题链接

$(1)$ LeetCode 239. 滑动窗口最大值
$(2)$ 剑指 Offer 59 - I. 滑动窗口的最大值

二、解题报告

1、思路分析

  如果要维护一个队列，这个队列应该能够通过 $O(1)$ 的时间找到最大值，那么只有当 队首 元素是最大值时才能保证。
  对于两个位置的 $i$, $j$ 的数 $a[i]$ 和 $a[j]$，如果 $i<j$ 且 $a[i]\le a[j]$，那么 $a[i]$ 不会比 $a[j]$ 更优，也就是不需要将它存储到队列中。于是，$i_1<i_2<...<i_n$ 我们队列中的元素应该满足： $a[i_1]>a[i_2]>...>a[i_n]$，即 维护一个单调递减的队列。
  队尾元素 在原数组的下标 减去 队首元素 在原数组的下标 不能 大于 $k-1$，且由于知道下标，就能知道这个数本身，所以 单调队列 中 只需要存储原数组的下标即可。

2、时间复杂度

• 每个数最多入队一次，出队一次，所以总的时间复杂度为 $O(n)$。

3、代码详解

/**************************** 顺序表 实现队列 ****************************/
#define DataType int
#define maxn 100005

struct Queue {
    DataType data[maxn];
    int head, tail;
};

void QueueClear(struct Queue* que) {
    que->head = que->tail = 0;
}
void QueueEnqueue(struct Queue *que, DataType dt) {
    que->data[ que->tail++ ] = dt;
}
void QueueDequeueFront(struct Queue* que) {
    ++que->head;
}
void QueueDequeueRear(struct Queue* que) {
    --que->tail;
}

DataType QueueGetFront(struct Queue* que) {
    return que->data[ que->head ];
}
DataType QueueGetRear(struct Queue* que) {
    return que->data[ que->tail - 1 ];
}
int QueueGetSize(struct Queue* que) {
    return que->tail - que->head;
}
int QueueIsEmpty(struct Queue* que) {
    return !QueueGetSize(que);
}

/**************************** 顺序表 实现队列 ****************************/

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
/*

*/
 
int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize){
    int i, pos = 0;
    struct Queue *q = (struct Queue*)malloc( sizeof(struct Queue));       // (1) 
    int *ret = (int *)malloc( (numsSize - k + 1) * sizeof(int) );         // (2) 

    *returnSize = numsSize - k + 1;                                       // (3) 
    for(i = 0; i < numsSize; ++i) {
        while( !QueueIsEmpty(q) && i - QueueGetFront(q) > k-1 )           // (4) 
            QueueDequeueFront(q);
        while( !QueueIsEmpty(q) &&  nums[ QueueGetRear(q) ] <= nums[i])   // (5) 
            QueueDequeueRear(q);
        QueueEnqueue(q, i);                                               // (6) 
        if(i >= k - 1)
            ret[i - k + 1] = nums[ QueueGetFront(q) ];                    // (7) 
    }
    return ret;

}

• $(1)$ 申请一个队列的空间；
• $(2)$ 申请返回数组需要的空间；
• $(3)$ 返回数组的size；
• $(4)$ 队尾 减去 队首 小于等于 $k-1$；
• $(5)$ 队列元素存到是下标，所以需要索引到值，令值单调递减；
• $(6)$ 满足以上两个条件以后，第 $i$ 个下标 塞入队列；
• $(7)$ 取队列头，就是最大值；

---

三、本题小知识

   单调队列在进行入队出队过程中，虽然外层有个 for 循环，内存有个 while，看起来是循环套循环，但是，这里有个均摊复杂度的概念，就是所有元素一定只有一次入队出队的机会，所以总的时间复杂度不会超过 $O(n)$。

---