长度最小的子数组

leetcode :209 题

需求：

给定一个正整数的数组，和一个target，找出数组中 子数组和大于等于 target的最小连续子数组。

示例 1：

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

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

暴力解法：两层for循环。

双指针思路（滑动窗口思路）：

C#：

public class Solution {
    public int MinSubArrayLen(int target, int[] nums) {
        int i=0;
        int sum=0;//用于统计子数组的和
        int result = nums.Length + 1;//用于记录最小字数组的长度
        for (int j=0;j<nums.Length;j++)
        {
            sum += nums[j];
            //如果字数组的和符合条件
            while(sum >= target)
            {
                int sublen = j - i + 1 ;//取当前符合条件的 [i,j] 区间
                result = min(result,sublen);//与前一个符合的区间比较取最小
                //移动左侧窗口
                sum -= nums[i++];
            }
        }
        return result == nums.Length +1 ? 0 :result;
    }
    public int min(int val1,int val2)
    {
        return val1 < val2? val1 :val2; 
    }
}

Rust：

impl Solution {
    pub fn min_sub_array_len(target: i32, nums: Vec<i32>) -> i32 {
        
        let mut i = 0;
        let mut sum = 0;
        let mut result = nums.len() + 1;
        for j in 0..nums.len()
        {
            sum += nums[j];
            while sum >= target
            {
                let subLen = j - i + 1;
                result = Solution::min(result,subLen);
                sum -= nums[i];
                i += 1;
            }
        }
        if result == nums.len() +1
        {
            return 0;
        }
        result as i32
    }
    pub fn min(val1:usize,val2:usize) -> usize
    {
        if val1 < val2
        {
            return val1;
        }
        val2
    }
}