在队列中，索引对应的元素值是递减的，队首元素对应的元素值最大，队尾元素对应的元素值最小。

在这里双端队列来实现单调。队列中存储的是数组中元素的索引。

初始化一个h，t变量用来表示队头队尾

先从数组的第一个元素开始遍历，维护一个递减的双端队列。在这个阶段，由于窗口大小为 k，所以只需要遍历数组的前 k-1 个元素。

如果当前元素大于队尾元素，则将队尾元素出队，直到队列为空或者当前元素小于等于队尾元素。然后将当前元素的索引入队。

在这个时候，虽然队列里的东西不一定是k-1，但是初始化的窗口已经到了k-1.

然后从第 k 个元素开始遍历数组，每次遍历都会对双端队列进行维护，并且将当前窗口的最大值，也就是队头元素（h）记录在结果数组中。

在滑动窗口阶段，从第 k 个元素开始遍历数组。继续维护递减的双端队列，将当前元素入队。然后将当前窗口的最大值记录在结果数组中。

在每次左边窗口加1时，判断队首元素是否已经不在当前窗口内，如果不在，则将队首元素出队。

最后返回答案数组即可

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] deque = new int[nums.length];
        int h = 0, t = 0;
        for (int i = 0; i < k - 1; i++) {
            while (h < t && nums[deque[t - 1]] <= nums[i]) {
                t--;
            }
            deque[t++] = i;
        }
        int x = nums.length - k + 1;
        int[] ans = new int[x];
        for (int l = 0, r = k - 1; l < nums.length - k + 1; l++, r++) {
            while (h < t && nums[deque[t - 1]] <= nums[r]) {
                t--;
            }
            deque[t++] = r;
            ans[l] = nums[deque[h]];
            if (deque[h] == l) {
                h++;
            }
        }
        return ans;
    }
}

// 定义一个指向整数的指针数组，用于存储滑动窗口中元素的索引
int deque[numsSize];

// 初始化头部和尾部索引
int h = 0, t = 0;

// 填充双端队列的前 k-1 个元素
for (int i = 0; i < k - 1; i++) {
    // 维护双端队列的单调性：移除所有比当前元素小的元素
    while (h < t && nums[deque[t - 1]] <= nums[i]) {
        t--;
    }
    // 将当前元素的索引加入到双端队列中
    deque[t++] = i;
}

// 分配内存用于存储滑动窗口最大值的结果
int* ans = (int*)malloc(sizeof(int) * (numsSize - k + 1));

// 滑动窗口遍历整个数组
for (int l = 0, r = k - 1; l < numsSize - k + 1; l++, r++) {
    // 维护双端队列的单调性：移除所有比当前元素小的元素
    while (h < t && nums[deque[t - 1]] <= nums[r]) {
        t--;
    }
    // 将当前窗口的最后一个元素的索引加入到双端队列中
    deque[t++] = r;

    // 当前窗口的最大值是双端队列头部元素对应的值
    ans[l] = nums[deque[h]];

    // 如果双端队列头部元素的索引正好是窗口左边界，则移除头部元素
    if (deque[h] == l) {
        h++;
    }
}

// 更新返回的最大值数组的大小
*returnSize = numsSize - k + 1;

// 返回结果数组
return ans;

class Solution {
    // 初始化ans为一个较大的数值，以便在遍历过程中找到更小的值
    int ans = 100001;

    public int shortestSubarray(int[] nums, int k) {
        // deque数组用于存储当前考虑的子数组的索引，实现单调队列的功能
        int[] deque = new int[nums.length + 1];
        // 初始化双端队列的头和尾索引
        int h = 0, t = 0;
        // sum数组用于存储前缀和，sum[i]表示nums从0到i的元素和
        long[] sum = new long[nums.length + 1];
        // 初始化前缀和数组的第一个元素为0
        sum[0] = 0;

        // 循环遍历数组nums
        for (int i = 0; i <= nums.length; i++) {
            // 如果不是第一个元素，计算当前位置的前缀和
            if (i != 0)
                sum[i] = sum[i - 1] + nums[i - 1];

            // 维护单调队列：移除所有使得sum[i] - sum[deque[h]] >= k的元素
            // 因为这些元素之前的子数组和已经不可能满足和至少为k
            while (h < t && sum[i] - sum[deque[h]] >= k) {
                ans = Math.min(ans, i - deque[h++]); // 更新最短子数组长度
            }
            // 维护单调队列：移除所有使得sum[i] <= sum[deque[t - 1]]的元素
            // 因为这些元素对于找到和至少为k的最短子数组没有帮助
            while (h < t && sum[i] <= sum[deque[t - 1]]) {
                t--; // 移除队尾元素
            }
            // 将当前元素的索引加入到单调队列中
            deque[t++] = i;
        }

        // 如果ans没有被更新，则说明不存在和至少为k的子数组，返回-1
        return ans > 100000 ? -1 : ans;
    }
}