【LeetCode每日一题】——239.滑动窗口最大值

一【题目类别】

• 队列

二【题目难度】

• 困难

三【题目编号】

• 239.滑动窗口最大值

四【题目描述】

• 给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
• 返回 滑动窗口中的最大值 。

五【题目示例】

• 示例 1：
  • 输入：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
1
2
3
4
5
6
7
8

• 示例 2：
  • 输入：nums = [1], k = 1
  • 输出：[1]

六【解题思路】

• 利用单调队列的思想，单调队列就是在队列的一端要么是单调减，要么是单调增。很明显本题应该使用单调减的队列，每次都从队列头部取出最大的元素
• 这道题和昨天的【LeetCode每日一题】——950.按递增顺序显示卡牌有异曲同工之妙，使用队列存储数组值的下标。维护这个单调队列，只要新来的元素比队列尾部的元素值要大，那么说明当前这个滑动窗口的最大值可能要更改了，所以弹出小的值，将最大的值调整到单调队列的最前面
• 这个清楚之后后面就好做了，我们只需要不停的遍历数组，第一组滑动窗口需要判断一下是否到达指定大小了，第一组滑动窗口的最大值确定后，后面每循环一次，就能确定一个最大值
• 在遍历的过程中还要注意队列中的元素个数不能超过滑动窗口的长度
• 最后返回结果即可

七【题目提示】

• $1<=nums.length<=10^5$
• $-10^4<=nums[i]<=10^4$
• $1<=k<=nums.length$

八【时间频度】

• 时间复杂度：$O(n)$，其中$n$为数组大小
• 空间复杂度：$O(k)$，其中$k$为滑动窗口大小

九【代码实现】

1. Java语言版

package Queue;

import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedList;

public class p239_SlidingWindowMaximum {

    public static void main(String[] args) {
        int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
        int k = 3;
        int[] res = maxSlidingWindow(nums, k);
        System.out.println(Arrays.toString(res));
    }

    public static int[] maxSlidingWindow(int[] nums, int k) {
        int len = nums.length;
        if (nums == null || len < 2) {
            return nums;
        }
        Deque<Integer> queue = new LinkedList<>();
        int[] res = new int[len - k + 1];
        for (int i = 0; i < len; i++) {
            while (!queue.isEmpty() && nums[queue.peekLast()] <= nums[i]) {
                queue.pollLast();
            }
            queue.offer(i);
            if (queue.peek() <= i - k) {
                queue.poll();
            }
            if (i + 1 >= k) {
                res[i + 1 - k] = nums[queue.peek()];
            }
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2. C语言版

#include
#include

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

	int* queue = (int*)malloc(sizeof(int) * numsSize);
	int front = 0;
	int rear = 0;
	int* res = (int*)malloc(sizeof(int) * (numsSize - k + 1));
	*returnSize = 0;
	for (int i = 0; i < numsSize; i++)
	{
		while ((front < rear) && nums[queue[rear - 1]] <= nums[i])
		{
			rear--;
		}
		queue[rear++] = i;
		if (queue[front] <= i - k)
		{
			front++;
		}
		if (i + 1 >= k)
		{
			res[(*returnSize)++] = nums[queue[front]];
		}
	}
	return res;
}

/*主函数省略*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

十【提交结果】

1. Java语言版
   

2. C语言版