leetcode.209 长度最小的子数组

思路一：滑动窗口

刚开始右边界拓宽，满足条件之后，左边界变窄，缩小边界找最小长度，（有点像毛毛虫向前蠕动的感觉，但不是）

时间复杂度：O(n)，其中 n是数组的长度。指针 head、end 最多各移动 n 次。

空间复杂度：O(1)。

class Solution {

    
    public int minSubArrayLen(int target, int[] nums) {
        if(nums==null || nums.length==0)
            return 0;
        int total=0;
        int head=0;
        int end=0;//初始化窗口为1
        int len=0;
        int curMinLen=nums.length+1;//作为第一次长度比较的对象（可以是任意大的数，只要比数组长度大即可）
        while(end<nums.length)//控制窗口右边界
        {
            total +=nums[end];//窗口右边界变大
            end++;
            while(total>=target)//寻找最小长度
            {
                len=Math.min(curMinLen,end-head);
                max=curMinLen;//
                total -= nums[head];
                head++;//窗口左边界变小，并循环直到不满足条件
            }
        }
        return curMinLen;
    }
}

第二次做注意标记：curMinLen取nums.length+1要不就取Integer.MaxValue

方式二：暴力破解,两层循环，外循环控制当前的子数组的头，内循环控制子数组的尾

时间复杂度O（n^2）空间常数级

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        if(nums==null || nums.length==0)
        return 0;
        int curLeastLen=nums.length+1;//当前最小子数组长度初始化为不可能的值
        for(int i=0;i<nums.length;i++)
        {
            int sum=0;
            for(int j=i;j<nums.length;j++)
            {
                sum += nums[j];
                if(sum>=target)
                {
                   curLeastLen=Math.min(curLeastLen,j-i+1);
                   break;
                }
            }
        }
       return  curLeastLen==nums.length+1?0:curLeastLen;
    }
}

第二次做注意点标记：curMinLen取nums.length+1,或者取Integer.MAX_VALUE