双指针 长度最小的子数组

题目

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

示例:

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

进阶:

如果你已经完成了O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。

解法一

1.从nums[0]开始，一直累加，当>=s之后统计位数i+1-j 2.回到nums[1]继续上一步操作

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int i=0,l=nums.length,j=0;
        int min=9999;
        int sum=0;
        if(l==0) return 0;
        sum=nums[0];
        if (sum>=s) return 1;
        for (i=1;i<l;i++){

            
            sum+=nums[i];
            if(sum>=s){


                    min=Math.min(min,i+1-j);

                    
                    j++;
                    i=j;
                    sum=nums[j];
                    if (sum>=s) return 1;



                
            }
        }
        if(min==9999) min=0;
        return min;
    }
}

总结：这也是双指针的思想，但是却很高的时间空间复杂度

时间复杂度O（nlogn)

原因在于

1. 多个if判断

2. 后面的指针没有必要再往从i开始加，因为之前的一个sum才刚刚大过s;现在去掉第一个数字之后，如果小于前面也必然小于

解法二 ：改进

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int ans = Integer.MAX_VALUE;
        int start = 0, end = 0;
        int sum = 0;
        while (end < n) {
            sum += nums[end];
            while (sum >= s) {
                ans = Math.min(ans, end - start + 1);
                sum -= nums[start];
                start++;
            }
            end++;
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }
}

时间复杂度O(N)