长度最小的子数组（二分查找 和 双指针滑动窗）

问题描述：

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

示例: 

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-size-subarray-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

算法一：二分查找

先构建一个sums[]数组，sums[i]为从0到i的元素之和。

并且有如下结论：

i到j之间元素之和 sum= sums[j] - sums[i] + nums[i]

由于想要找到sum >= a的问题可以转化为：找 sums[j] >= a + sums[i] - nums[i] = target的问题，

如此就可以采用二分查找的方式从sums中找到不小于target的第一个元素。

实现代码如下：

     public static int minSubArrayLen(int s, int[] nums) {
         int result = nums.length + 1;
         int[] sums = new int[nums.length];
         for (int i = 1; i < sums.length; i++) {
             sums[i] = sums[i - 1] + nums[i];
         }
         // 找到从i到N-1满足条件的解
         for (int i = 0; i < sums.length; i++) {
             if (sums[sums.length - 1] - sums[i] + nums[i] < s) {
                 break;
             }
             int left = i, right = sums.length -1, mid;
             int temp = s + sums[i] - nums[i];
             int optIndex = binSearch(sums, temp, left, right);
             result = Math.min(result, optIndex - i + 1);
         }
         return result == nums.length + 1 ? 0 : result;
     }
     /*
      *  find sums[i] >= target first i 
      */
     public static int binSearch(int[] sums, int target, int left, int right) {
         int mid = 0;
         while (left < right - 1) {
             mid = left + (right - left) / 2;
             if (sums[mid] >= target) {
                 right = mid;
             } else {
                 left = mid;
             }
         }
         if (sums[left] >= target) {
             return left;
         }
         if (sums[right] >= target) {
             return right;
         }
         return -1;
     } 

该算法的时间复杂度为O（NlogN），额外空间复杂度为O（N）。

算法二：双指针+滑动窗

两个指针一个指向窗头，一个指向窗尾，并且维护窗内的元素之和大于等于a，并且长度最短。

判断窗类元素是否大于等于a，若满足则更新结果，并把头指正右移；否则移动尾指针。迭代上述过程直到尾指针到最后一个元素为止。

实现代码如下：

     public static int doublePointer(int s, int[] nums) {
         int result = nums.length + 1;
         int sum = 0;
         for (int start = 0,end = 0; end < nums.length;) {
             if (sum + nums[end] < s) {
                 sum += nums[end++];
             }else {
                 result = Math.min(result, end + 1 - start);
                 sum -= nums[start++];
             }
         }
         return result == nums.length + 1 ? 0 : result;
     }         

该算法由于只遍历一次，并且对于sum的计算都是O（1）的因此时间复杂度为O（N），由于只使用有限个中间变量，其额外空间复杂度为O（1）。