【算法】原地删除有序数组重复项的N种解法，总有一款适合你

一、问题

给定一个非严格递增排序的整数数组 nums，请、原地删除重复出现的元素，使得每个元素只出现一次。返回删除后数组的新长度。

要求：

1. 原地修改： 必须直接修改输入数组 nums。不允许使用额外的空间。
2. 相对顺序： 元素之间的相对顺序必须保持一致。
3. 返回唯一元素个数： 返回数组中唯一元素的个数 k。
4. 数组内容： 数组 nums 的前 k 个元素应包含唯一元素，并且按照它们最初在 nums 中出现的顺序排列。 nums 数组中下标 k 及之后的部分的内容可以任意修改，其值不影响结果。

示例：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_] // 下划线表示不重要的位置

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4,,,,,_]

解释：

函数应该返回新的长度 k = 5, 并且 nums 的前五个元素为 0, 1, 2, 3, 4。 不需要考虑数组中超出新长度后面的元素。

关键点：

• 非严格递增： 意味着数组是排序的，但不一定是严格升序 (允许重复元素)。
• 原地删除： 空间复杂度必须是 O(1)。
• 相对顺序不变： 删除重复元素后，剩余元素的顺序要与原始数组中的顺序相同。

二、问题分析

核心目标： 从已排序的数组中移除重复元素，确保每个唯一元素只出现一次，并返回唯一元素的数量。
约束条件：

• 原地操作： 这是最关键的约束。我们不能创建新的数组来存储结果。必须直接修改原始数组。
• 相对顺序： 删除重复项后，唯一元素的相对顺序必须与原始数组保持一致。
• 排序特性： 输入数组是已排序的。这是一个重要的前提，允许我们使用更高效的算法。

解题思路： 由于数组已排序，可以使用双指针方法来解决这个问题。双指针方法通常用于原地操作，且效率较高。

• 慢指针（i）： 指向下一个非重复元素应该放置的位置。
• 快指针（j）： 用于遍历数组，查找非重复元素。

算法步骤：

1. 初始化：
   • i = 0 （慢指针，指向数组的第一个位置，即第一个唯一元素应该放置的位置）。
   • j = 1 （快指针，从数组的第二个位置开始遍历）。
2. 遍历数组：
   • 使用 j 遍历数组 nums。
   • 如果 nums[j] != nums[i]： 说明 nums[j] 是一个新的唯一元素。
     • 将 i 向前移动一位（i++）。
     • 将 nums[j] 复制到 nums[i] 的位置（nums[i] = nums[j]）。
   • 否则 (如果 nums[j] == nums[i])： 说明 nums[j] 是一个重复元素，跳过它。
3. 返回结果： 循环结束后，i + 1 就是数组中唯一元素的数量（因为 i 是索引，从 0 开始）。

示例演示： 假设 nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]

步骤	i	j	nums	说明
1	0	1	[0, 0, 1, 1, 1, 2, 2, 3, 3, 4]	初始化
2	0	2	[0, 0, 1, 1, 1, 2, 2, 3, 3, 4]	nums[2] != nums[0], i++, nums[1] = nums[2]
3	1	3	[0, 1, 1, 1, 1, 2, 2, 3, 3, 4]	nums[3] != nums[1], i++, nums[2] = nums[3]
4	2	4	[0, 1, 2, 1, 1, 2, 2, 3, 3, 4]	nums[4] != nums[2], i++, nums[3] = nums[4]
5	3	5	[0, 1, 2, 1, 1, 2, 2, 3, 3, 4]	nums[5] != nums[3], i++, nums[4] = nums[5]
6	4	6	[0, 1, 2, 3, 1, 2, 2, 3, 3, 4]	nums[6] != nums[4], i++, nums[5] = nums[6]
7	5	7	[0, 1, 2, 3, 4, 2, 2, 3, 3, 4]	nums[7] != nums[5], i++, nums[6] = nums[7]
8	6	8	[0, 1, 2, 3, 4, 3, 2, 3, 3, 4]	nums[8] != nums[6], i++, nums[7] = nums[8]
9	7	9	[0, 1, 2, 3, 4, 3, 3, 3, 3, 4]	nums[9] != nums[7], i++, nums[8] = nums[9]
10	8	10	[0, 1, 2, 3, 4, 3, 3, 3, 4, 4]	循环结束

最终结果：nums = [0, 1, 2, 3, 4, ...]，返回 i + 1 = 5

复杂度分析：

• 时间复杂度： O(n)，其中 n 是数组的长度。我们需要遍历数组一次。
• 空间复杂度： O(1)，原地操作，只使用了常数级别的额外空间。

三、算法实现

由于数组已排序，可以使用双指针方法来解决这个问题。

1. 初始化快慢指针。
2. 遍历数组。
3. 返回结果。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.size() < 2)
            return nums.size();
        int left = 0;
        int right = 1;
        while (right < nums.size()) {
            if (nums[right] == nums[left])
                ++right;
            else 
                nums[++left] = nums[right++];
        }
        return left + 1;
    }
};

四、问题变体：最多保留两次

删除有序数组中的多余重复项 (最多保留两次)： 给定一个已排序的数组 nums，请 原地 删除重复出现的元素，使得每个元素最多出现两次。返回删除后数组的新长度。

要求：

1. 原地修改： 必须直接修改输入数组 nums。不允许使用额外的数组空间。
2. O(1) 额外空间： 必须在 O(1) 的额外空间复杂度下完成此操作。
3. 相对顺序： 元素的相对顺序必须保持一致。
4. 返回值： 返回删除重复元素后的数组的新长度 k。
5. 数组内容： 数组 nums 的前 k 个元素应该包含处理后的元素，超出 k 长度的部分可以忽略。

示例：

输入：nums = [1,1,1,2,2,3]
输出：5, nums = [1,1,2,2,3,_] // 下划线表示不重要的位置

输入：nums = [0,0,0,1,1,1,2,2,3,3,4]
输出：9, nums = [0,0,1,1,2,2,3,3,4,_]

说明：

• 对于 nums = [1,1,1,2,2,3]，函数应该返回新的长度 k = 5，并且 nums 的前五个元素为 1, 1, 2, 2, 3。
• 对于 nums = [0,0,0,1,1,1,2,2,3,3,4]，函数应该返回新的长度 k = 9，并且 nums 的前九个元素为 0, 0, 1, 1, 2, 2, 3, 3, 4。

关键点：

• 有序数组： 输入数组是已排序的，利用这一特性可以优化算法。
• 最多保留两次： 每个元素最多允许出现两次。
• 原地修改 + O(1)： 限制了算法的选择，必须采用空间复杂度为常数的算法。

五、分析和代码实现

5.1、问题分析

可以将问题分解为以下几个子问题：

• 识别重复项： 如何有效地识别重复出现的元素？ 由于数组是有序的，相邻元素相同则为重复。
• 计数： 如何记录每个元素出现的次数？ 需要一个变量来追踪当前元素出现的次数。
• 原地修改： 如何在不使用额外空间的情况下，将需要保留的元素移动到数组的前面？ 使用双指针方法是关键。
• 更新长度： 如何计算并返回修改后的数组长度？ 慢指针的最终位置 + 1 就是新长度。

算法思路： 基于双指针方法，结合计数器来解决此问题。

• 慢指针（i）： 指向下一个要保留的元素应该放置的位置。
• 快指针（j）： 用于遍历数组，检查元素是否应该被保留。
• 计数器（count）： 记录当前元素连续出现的次数。

5.2、算法实现

算法步骤：

1. 初始化：

   • i = 0 (慢指针)
   • j = 0 (快指针)
   • count = 1 (初始计数为 1，因为 nums[0] 至少出现一次)

2. 遍历数组：

   • 循环 j 从 1 到 nums.length - 1。
   • 情况 1：nums[j] == nums[j-1] (遇到相同元素)
     • count++ (增加计数器)。
     • 如果 count <= 2： 说明当前元素允许被保留。
       • 将 nums[j] 复制到 nums[i] 的位置 ( nums[i] = nums[j] )。
       • i++ (移动慢指针)。
   • 情况 2：nums[j] != nums[j-1] (遇到不同元素)
     • nums[i] = nums[j]
     • i++
     • count=1

3. 返回结果： 循环结束后，i 就是数组中应该保留的元素个数，因此返回 i。

示例演示： 假设 nums = [1,1,1,2,2,3]

步骤	i	j	count	nums	说明
1	0	0	1	[1, 1, 1, 2, 2, 3]	初始化
2	0	1	2	[1, 1, 1, 2, 2, 3]	nums[1] == nums[0], count++, count <= 2, nums[0] = nums[1], i++
3	1	2	3	[1, 1, 1, 2, 2, 3]	nums[2] == nums[1], count++, count > 2，跳过
4	1	3	1	[1, 1, 1, 2, 2, 3]	nums[3] != nums[2], count = 1, nums[1] = nums[3], i++
5	2	4	2	[1, 2, 1, 2, 2, 3]	nums[4] == nums[3], count++, count <= 2, nums[2] = nums[4], i++
6	3	5	1	[1, 2, 2, 2, 2, 3]	nums[5] != nums[4], count = 1, nums[3] = nums[5], i++

最终结果：nums = [1, 1, 2, 2, 3, ...]，返回 i = 5

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n < 3)
            return n;
        int left = 1;
        int count = 1;
        for (int right = 1; right < n; ++right) {
            if (nums[right - 1] == nums[right]) {
                ++count;
                if (count <= 2) {
                    nums[left] = nums[right];
                    ++left;
                }
            } else {
                nums[left] = nums[right];
                ++left;
                count = 1;
            }
        }
        return  left;
    }
};

复杂度分析：

• 时间复杂度： O(n)，其中 n 是数组的长度。需要遍历数组一次。
• 空间复杂度： O(1)，使用了常数级别的额外空间（i, j, count）。

5.3、快慢指针（推荐）

原理：

• slow 指针初始值为 2，因为它表示新数组中前两个元素已经确定（即原数组的前两个元素）。
• fast 指针从 2 开始遍历数组。
• 如果 nums[fast] 与 nums[slow - 2] 不相等，则说明 nums[fast] 可以被添加到新数组中，将其赋值给 nums[slow]，并同时递增 slow 指针。
• 如果 nums[fast] 与 nums[slow - 2] 相等，则说明 nums[fast] 是多余的重复元素，直接跳过。
• 循环结束后，slow 指针的值就是新数组的长度。

示例演示： 假设 nums = [1,1,1,2,2,3]

步骤	slow	fast	nums	说明
1	2	2	[1, 1, 1, 2, 2, 3]	初始化
2	2	3	[1, 1, 1, 2, 2, 3]	nums[3] != nums[slow - 2] (2 != 1)，nums[slow] = nums[fast] (nums[2] = 2)，slow++
3	3	4	[1, 1, 2, 2, 2, 3]	nums[4] != nums[slow - 2] (2 != 1)，nums[slow] = nums[fast] (nums[3] = 2)，slow++
4	4	5	[1, 1, 2, 2, 2, 3]	nums[5] != nums[slow - 2] (3 != 2)，nums[slow] = nums[fast] (nums[4] = 3)，slow++

最终结果：nums = [1, 1, 2, 2, 3, ...]，返回 slow = 5

代码实现：

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n <= 2) {
            return n; // 少于等于两个元素，直接返回
        }

        int slow = 2; // slow指针指向下一个要放置的位置，从第三个位置开始
        int fast = 2; // fast指针用于遍历数组

        while (fast < n) {
            // 如果当前元素与slow指针的前两个元素不同，说明可以保留
            if (nums[fast] != nums[slow - 2]) {
                nums[slow] = nums[fast]; // 将fast指针指向的元素移动到slow指针的位置
                slow++; // slow指针向后移动
            }
            fast++; // fast指针始终向后移动
        }

        return slow; // slow指针的值就是新数组的长度
    }
};

复杂度分析：

• 时间复杂度： O(n)，其中 n 是数组的长度。只需要遍历数组一次。
• 空间复杂度： O(1)，使用了常数级别的额外空间（slow, fast）。

5.4、低效率的代码实现

思路：对于超过 2 次的重复元素，超出部分使用循环将它们移动到数组的末尾。

思路是正确的，但存在一些效率问题和潜在的错误。核心问题在于，对于每个需要删除的元素，都进行一次循环移动操作，这会导致时间复杂度过高，尤其是在重复元素较多的情况下。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n < 3)
            return n;
        int left = 0;
        for (int right = 1; right < n; ++right) {
            if (nums[left] != nums[right]) {
                left = right;
                continue;
            }
            if (right - left > 1) {
                for (int i = right - 1; i < (n - 1); ++i) 
                    std::swap(nums[i], nums[i + 1]);
                --n;
                --right;
            }
        }
        return n;
    }
};

六、总结

双指针方法是一个解决此类原地修改问题的有效方法。通过维护两个指针，一个指向下一个唯一元素的位置，另一个用于遍历数组，我们可以高效地删除重复项并保持相对顺序不变。 理解排序数组的特性对于选择正确的算法至关重要。