数组部分的算法--长度最小的子数组

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

提示：

    1 <= target <= 10^9
    1 <= nums.length <= 10^5
    1 <= nums[i] <= 10^5

思路算法：

法一：最容易想到的是暴力求解，使用两个 for 循环，一个 for 循环固定一个数字比如 i，另一个 for 循环从 i 的下一个元素开始累加，当和大于等于 s 的时候终止内层循环，顺便记录下最小长度。

class Solution {
        public int minSubArrayLen(int s, int[] nums) {
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < nums.length; i++) {
            int sum = nums[i];
            if (sum >= s)
                return 1;
            for (int j = i + 1; j < nums.length; j++) {
                sum += nums[j];
                if (sum >= s) {
                    min = Math.min(min, j - i + 1);
                    break;
                }
            }
        }
        return min == Integer.MAX_VALUE ? 0 : min;
    }
    }

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

暴力解法提交后已经超时了

法二：滑动窗口，根据当前子序列和大小的情况，不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置：如果当前窗口的值大于s了，窗口就要向前移动了。

窗口的结束位置：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

在代码中我们使用两个指针，一个 left 指向队头，一个 right 指向队尾。每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)

class Solution {
    // 滑动窗口
    public int minSubArrayLen(int s, int[] nums) {
        int left = 0;// 滑动窗口起始位置
        int sum = 0;// 滑动窗口数值之和
        int result = Integer.MAX_VALUE;// 滑动窗口的长度
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            // 这里使用while，每次更新 left（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];//滑动窗口的精髓之处，不断变更left（子序列的起始位置）
            }
        }
        //如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(1)