本题要求在一个仅包含 0 和 1 的一维数组中，找出最长的连续 1 的片段长度。下面分别使用三种思路进行求解，并分析常见错误与优化方向。

单侧遍历法

最直观的思路是顺序扫描数组，维护一个计数器 curLen 记录当前连续 1 的数量，遇到 0 时更新全局最大值并重置计数器。需要注意：若数组以 1 结尾，循环结束后仍需用最终计数值修正结果，否则会漏掉末尾段。

错误示范：忘记在循环外判断

public int FindMaxConsecutiveOnes(int[] nums) {
    int maxLen = 0, cur = 0;
    for (int i = 0; i < nums.Length; i++) {
        if (nums[i] == 1) cur++;
        else {
            if (cur > maxLen) maxLen = cur;
            cur = 0;
        }
    }
    return maxLen; // 漏处理尾部连续 1
}

输入 [1,1,0,1,1,1] 将输出 2，因为末尾的 3 个 1 未被计入最大值。

修正后的正确写法：

public int FindMaxConsecutiveOnes(int[] nums) {
    int maxLen = 0, cur = 0;
    for (int i = 0; i < nums.Length; i++) {
        if (nums[i] == 1) cur++;
        else {
            maxLen = Math.Max(maxLen, cur);
            cur = 0;
        }
    }
    maxLen = Math.Max(maxLen, cur); // 处理尾部
    return maxLen;
}

该方法时间复杂度 O(n)，空间 O(1)，但只击败了约半数提交，说明存在常数级优化空间。

双指针双向扫描（不推荐）

尝试同时从数组两端向中间扫描，试图减少循环次数，但逻辑复杂度大幅增加，性能提升微乎其微。核心思路：分别记录左侧当前连续 1 长度 leftCur 和右侧当前连续 1 长度 rightCur，以及左右各自遇到过的最大长度 maxLeft、maxRight。扫描结束后需判断中间段是否贯通：若 leftCur 和 rightCur 均不为零且中间相遇部分均为 1，则连贯长度需合并计算。

public int FindMaxConsecutiveOnes(int[] nums) {
    int maxLeft = 0, maxRight = 0;
    int leftCur = 0, rightCur = 0;
    int n = nums.Length;
    int half = (n + 1) / 2;

    for (int i = 0; i < half; i++) {
        if (nums[i] == 1) leftCur++;
        else {
            maxLeft = Math.Max(maxLeft, leftCur);
            leftCur = 0;
        }
        if (nums[n - 1 - i] == 1) rightCur++;
        else {
            maxRight = Math.Max(maxRight, rightCur);
            rightCur = 0;
        }
    }

    int ans;
    if (leftCur == 0 || rightCur == 0) {
        // 未贯通，取各分段最大值
        ans = MaxOfFour(leftCur, rightCur, maxLeft, maxRight);
    } else {
        // 贯通，合并中间段（长度为奇时减 1）
        int middle = leftCur + rightCur - (n % 2);
        ans = Math.Max(middle, Math.Max(maxLeft, maxRight));
    }
    return ans;
}

int MaxOfFour(int a, int b, int c, int d) {
    return Math.Max(Math.Max(a, b), Math.Max(c, d));
}

这种写法容易出错（例如变量名误用），且实测效率提升不明显，不推荐实际使用。

滑动窗口 / 双指针一次遍历

使用快慢指针 slow 和 fast，当遇到 0 时计算窗口大小并移动慢指针。这样无需额外在循环外处理尾部，因为每次右指针跨过 0 时直接结算上一段长度。

public int FindMaxConsecutiveOnes(int[] nums) {
    int slow = 0, fast = 0;
    int maxSize = 0;
    while (fast < nums.Length) {
        if (nums[fast] == 0) {
            maxSize = Math.Max(maxSize, fast - slow);
            slow = fast + 1;
        }
        fast++;
    }
    // 结尾段由 fast 超界时自然结算
    maxSize = Math.Max(maxSize, fast - slow);
    return maxSize;
}

更简洁的写法：遍历时动态维护当前连续长度，省去慢指针。

public int FindMaxConsecutiveOnes(int[] nums) {
    int max = 0, cur = 0;
    foreach (int v in nums) {
        if (v == 1) {
            cur++;
            max = Math.Max(max, cur);
        } else {
            cur = 0;
        }
    }
    return max;
}

第二种写法在每次遇到 1 时即时更新最大值，从而完全避免了循环后的额外判断，代码更加优雅，常数时间也更优。