双指针算法实现有序数组去重与LeetCode题解

1. 问题背景与核心需求

这道来自LeetCode的经典题目看似简单，却蕴含着数组操作的精妙之处。给定一个按非递减顺序排列的整数数组nums，我们需要原地删除重复出现的元素，使每个元素只出现一次，并返回新数组的长度。要求必须在不使用额外数组空间的情况下完成，仅使用O(1)的额外空间。

在实际开发中，类似场景比比皆是——处理日志文件中的重复记录、清理数据库中的冗余数据，或是准备机器学习训练集时的去重操作。这道题的价值不仅在于算法本身，更在于培养我们处理有序数据时的高效思维。

2. 解法思路与双指针原理

2.1 暴力解法的局限性

新手最容易想到的方法是创建新数组存储唯一元素，但这违反了题目"原地修改"的核心要求。另一种思路是遇到重复就删除元素，但数组删除操作的时间复杂度高达O(n)，导致整体复杂度变为O(n²)，在大数据量时性能堪忧。

2.2 快慢指针的优雅解法

快慢双指针（又称龟兔指针）是解决这类原地修改问题的利器。其核心思想是：

• 慢指针（slow）：标记下一个唯一元素应该存放的位置
• 快指针（fast）：遍历数组寻找下一个不重复的元素

具体操作流程：

1. 初始化slow=0, fast=1
2. 当nums[fast] ≠ nums[slow]时，说明找到新元素
   • 先移动slow到下一个位置
   • 将nums[fast]的值复制到nums[slow]
3. 无论是否找到新元素，fast都持续向前移动

这种方法的精妙之处在于，它通过元素覆盖而非删除来避免数组移位，将时间复杂度优化到O(n)，空间复杂度保持O(1)。

3. Python实现详解

3.1 基础实现代码

python复制def removeDuplicates(nums):
    if not nums:
        return 0
    
    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]
    
    return slow + 1

3.2 关键点解析

1. 边界处理：空数组直接返回0
2. 循环从1开始：因为第一个元素无需比较
3. 赋值时机：只有发现不同元素时才移动慢指针
4. 返回值：slow是索引，长度需要+1

注意：题目不要求考虑新长度之后的元素，但实际测试中LeetCode会检查数组前n位是否正确

3.3 代码优化技巧

1. 使用enumerate替代range：

python复制for fast, num in enumerate(nums[1:], 1):

2. 海象运算符(Python 3.8+)简化：

python复制if (num := nums[fast]) != nums[slow]:

3. 提前终止：当fast剩余元素数 <= (slow+1)时可提前退出循环

4. 复杂度分析与数学证明

4.1 时间复杂度

• 最佳情况：已去重数组，比较n-1次，赋值0次 → O(n)
• 最坏情况：全相同数组，比较n-1次，赋值0次 → O(n)
• 平均情况：随机数据，比较n-1次，赋值m次(m为唯一元素数) → O(n)

4.2 空间复杂度

仅使用常数个额外变量 → O(1)

4.3 正确性证明

循环不变式：在每次迭代开始时，nums[0..slow]包含所有已发现的唯一元素，且有序。

初始化：slow=0时，nums[0]显然是第一个唯一元素。
保持：当nums[fast]≠nums[slow]时，扩展唯一序列。
终止：fast遍历完数组时，nums[0..slow]包含全部唯一元素。

5. 变种问题与扩展思考

5.1 允许最多k个重复

通用解法模板：

python复制def removeDuplicates(nums, k=2):
    if len(nums) <= k:
        return len(nums)
    
    slow = k
    for fast in range(k, len(nums)):
        if nums[fast] != nums[slow - k]:
            nums[slow] = nums[fast]
            slow += 1
    
    return slow

5.2 无序数组去重

此时双指针法失效，应考虑：

1. 先排序后使用双指针 → O(nlogn)时间
2. 使用哈希集合 → O(n)时间但O(n)空间

5.3 实际工程应用

1. 数据库查询结果去重
2. 时间序列数据清洗
3. 图像处理中的像素去噪
4. 机器学习特征工程中的维度压缩

6. 调试技巧与常见错误

6.1 典型错误案例

1. 忘记处理空数组输入
2. 返回值误写为slow而非slow+1
3. 比较时使用nums[fast] != nums[fast-1]导致逻辑混乱
4. 在移动slow指针前就进行赋值操作

6.2 可视化调试方法

以nums = [0,0,1,1,1,2,2,3,3,4]为例：

6.3 单元测试用例设计

python复制test_cases = [
    ([], 0),
    ([1], 1),
    ([1,1,2], 2),
    ([0,0,1,1,1,2,2,3,3,4], 5),
    ([i//2 for i in range(100)], 50)
]

7. 性能优化与语言特性

7.1 Python特定优化

1. 使用内置函数可能更快：

python复制import itertools
def removeDuplicates(nums):
    nums[:] = (k for k, _ in itertools.groupby(nums))
    return len(nums)

2. 内存视图减少拷贝：

python复制def removeDuplicates(nums):
    view = memoryview(nums)
    # ...双指针操作...

7.2 其他语言实现对比

C++实现示例：

cpp复制int removeDuplicates(vector<int>& nums) {
    if(nums.empty()) return 0;
    int slow = 0;
    for(int fast=1; fast<nums.size(); ++fast){
        if(nums[fast] != nums[slow]){
            nums[++slow] = nums[fast];
        }
    }
    return slow+1;
}

7.3 大数据量处理

当数组非常大时：

1. 考虑分块处理
2. 使用生成器替代列表
3. 多线程处理不同区段

8. 算法思维培养建议

1. 先尝试暴力解法，再思考优化
2. 画图辅助理解指针移动
3. 用特殊测试用例验证边界条件
4. 尝试从时空复杂度角度分析不同解法
5. 记录解题过程中的思维误区

这道题的价值不仅在于掌握双指针技巧，更在于培养以下能力：

• 对有序特性的敏感度
• 原地操作的空间优化意识
• 通过指针操作避免数据搬移的思维
• 严谨的边界条件处理习惯