删掉一个元素以后全为1的最长子数组

给你一个二进制数组 nums ，你需要从中删掉一个元素。

请你在删掉元素的结果数组中，返回最长的且只包含 1 的非空子数组的长度。

如果不存在这样的子数组，请返回 0 。

提示 1：

输入：nums = [1,1,0,1]
输出：3
解释：删掉位置 2 的数后，[1,1,1] 包含 3 个 1 。

示例 2：

输入：nums = [0,1,1,1,0,1,1,0,1]
输出：5
解释：删掉位置 4 的数字后，[0,1,1,1,1,1,0,1] 的最长全 1 子数组为 [1,1,1,1,1] 。

示例 3：

输入：nums = [1,1,1]
输出：2
解释：你必须要删除一个元素。

提示：

• 1 <= nums.length <= 10^5
• nums[i] 要么是 0 要么是 1 。

class Solution {
    public int longestSubarray(int[] nums) {
        int length = nums.length;
        //思路：设置头尾节点，都是0，中间发现0时，去除中间的0，计算left和right索引的个数
        List<Integer> zeroList = new ArrayList();
        zeroList.add(-1);
        for(int i = 0; i < length ;i++){
            if(nums[i] == 0){
                zeroList.add(i);
            }
        }
        //全是1，则必须去除一个元素
        if(zeroList.size() == 1){
            return length - 1;
        }
        zeroList.add(length);
        int result = 0;
        for(int i = 0 ; i < zeroList.size() ; i++){
            int index = zeroList.get(i);
            if(index == -1 || index >= length-1){
                continue;
            }
            result = Math.max(result,zeroList.get(i+1)   - zeroList.get(i-1) - 2);
        }
        return result;
    }
}

看了答案之后：

class Solution {
    public int longestSubarray(int[] nums) {
        int ans = 0; //结果
        // 左指针
        int l = 0;

        //子数组中0的数量
        int count0 = 0;
        //右指针
        //[0,1,1,0,1]
        for(int r = 0; r < nums.length ; r++){

            //从右指针为0开始向后遍历，1-nums[r]就是计算0的数量，如果nums[r]为0，cnt0就会加一
            count0 = count0 + (1 - nums[r]);
            System.out.println("l = " + l + "; r = " + r + "; count = " + count0);

            //说明前面的数组中包含两个0，所以才会>1，那这个时候可以操作左指针了，将左指针右滑
            if(count0 > 1){
                //数组
                count0 = count0 - (1-nums[l]);
                l++;
            }

            ans = Math.max(ans,r - l);
        }
        return ans;
    }
}