双指针算法解决力扣283移动零问题

1. 题目解析与需求拆解

力扣283题"移动零"是一个经典的数组操作问题。题目要求我们原地修改输入数组，将所有0移动到数组末尾，同时保持非零元素的原始相对顺序。这意味着我们不能使用额外的数组空间，必须在原数组上进行操作。

1.1 题目关键要求分析

1. 原地操作：不能创建新数组，空间复杂度必须为O(1)
2. 保持顺序：非零元素的相对顺序必须保持不变
3. 移动零：所有零元素必须移动到数组末尾

举个例子：

• 输入：[0,1,0,3,12]
• 输出：[1,3,12,0,0]

1.2 常见错误解法分析

很多初学者可能会想到以下两种错误解法：

1. 创建新数组法：

java复制// 错误解法1：创建新数组
public void moveZeroes(int[] nums) {
    int[] result = new int[nums.length];
    int index = 0;
    for (int num : nums) {
        if (num != 0) {
            result[index++] = num;
        }
    }
    // 这违反了原地修改的要求
    System.arraycopy(result, 0, nums, 0, nums.length);
}

2. 删除后补零法：

java复制// 错误解法2：删除后补零
public void moveZeroes(int[] nums) {
    int i = 0;
    while (i < nums.length) {
        if (nums[i] == 0) {
            // 删除操作需要移动大量元素，效率低
            for (int j = i; j < nums.length - 1; j++) {
                nums[j] = nums[j + 1];
            }
            nums[nums.length - 1] = 0;
        } else {
            i++;
        }
    }
}

这两种解法要么违反了原地修改的要求，要么时间复杂度太高（O(n²)），都不是最优解。

2. 双指针算法详解

2.1 算法核心思想

双指针算法是解决这类数组原地操作问题的利器。我们可以想象有两个指针在数组上移动：

• 慢指针(l)：指向下一个非零元素应该放置的位置
• 快指针(r)：遍历数组寻找非零元素

关键点：快指针负责探索，慢指针负责构建最终结果。这种分工使得我们可以在一次遍历中完成所有操作。

2.2 算法步骤拆解

1. 初始化两个指针l和r，都从0开始
2. 快指针r遍历整个数组：
   • 当nums[r] != 0时：
     • 交换nums[l]和nums[r]
     • l指针右移
3. 无论是否交换，r指针每次都右移

2.3 代码实现与注释

java复制class Solution {
    public void moveZeroes(int[] nums) {
        // l指针记录非零元素应该放置的位置
        int l = 0;
        // r指针遍历整个数组
        for (int r = 0; r < nums.length; r++) {
            // 发现非零元素
            if (nums[r] != 0) {
                // 交换l和r位置的元素
                swap(nums, l, r);
                // l指针右移，准备接收下一个非零元素
                l++;
            }
        }
    }
    
    // 辅助交换方法
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

2.4 算法复杂度分析

• 时间复杂度：O(n)，只需一次遍历
• 空间复杂度：O(1)，只使用了常数个额外空间

3. 算法执行过程示例

让我们通过一个具体例子来理解算法的执行过程。以输入数组[0,1,0,3,12]为例：

4. 算法优化与变种

4.1 优化交换操作

原算法中即使非零元素已经在正确位置也会进行交换。我们可以添加一个判断来避免不必要的交换：

java复制public void moveZeroes(int[] nums) {
    int l = 0;
    for (int r = 0; r < nums.length; r++) {
        if (nums[r] != 0) {
            // 只有当l和r不同时才需要交换
            if (l != r) {
                nums[l] = nums[r];
                nums[r] = 0;
            }
            l++;
        }
    }
}

4.2 双指针的另一种实现

有些开发者喜欢先移动非零元素，最后统一补零：

java复制public void moveZeroes(int[] nums) {
    int l = 0;
    // 先将所有非零元素移到前面
    for (int r = 0; r < nums.length; r++) {
        if (nums[r] != 0) {
            nums[l++] = nums[r];
        }
    }
    // 将剩余位置补零
    while (l < nums.length) {
        nums[l++] = 0;
    }
}

这种写法虽然需要两次遍历，但交换操作更少，在某些情况下可能更高效。

5. 常见问题与解决方案

5.1 为什么不能直接覆盖而非交换？

有初学者可能会想直接覆盖而非交换：

java复制// 错误写法
nums[l] = nums[r];
nums[r] = 0;

这在大多数情况下确实能工作，但当l和r指向同一个元素时（数组开头就是非零元素），会导致非零元素被错误地置零。

5.2 如何处理边界条件？

双指针算法天然能处理以下边界条件：

1. 全零数组：[0,0,0] → 无交换，保持原样
2. 无零数组：[1,2,3] → 每次都会交换，但l和r同步移动，最终结果不变
3. 单元素数组：[0]或[5] → 都能正确处理

5.3 为什么快指针每次都要移动？

快指针的任务是探索整个数组，寻找非零元素。无论当前元素是否为0，快指针都需要继续前进，这样才能确保不遗漏任何元素。

6. 双指针算法的应用场景

双指针算法不仅适用于移动零问题，还广泛应用于以下场景：

1. 有序数组的两数之和：一个指针从头部开始，一个从尾部开始
2. 移除重复元素：类似移动零，慢指针记录唯一元素位置
3. 盛水最多的容器：双指针从两端向中间移动
4. 链表中环的检测：快慢指针技巧

掌握双指针技巧的关键在于理解两个指针的分工和移动条件。在实际编程中，我建议先用具体例子手动模拟指针移动过程，再转化为代码，这样可以减少逻辑错误。