题目

给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k。去重后，返回唯一元素的数量 k。

nums 的前 k 个元素应包含 排序后 的唯一数字。下标 k - 1 之后的剩余元素可以忽略。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被 通过。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4,_,_,_,_,_]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

• 1 <= nums.length <= 3 * 104
• -100 <= nums[i] <= 100
• nums 已按 非递减 顺序排列。

---

Java语言

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length == 0) return 0;

        int slow = 0;
        for (int fast = 1; fast < nums.length; fast++) {
            if (nums[fast] != nums[slow]) {
                slow++;
                nums[slow] = nums[fast];
            }
        }

        return slow + 1;
    }
}

核心思路： 快慢双指针。slow 指向当前不重复部分的最后一个位置，fast 快速扫描整个数组。遇到不重复的值就放到 slow 的下一个位置。

---

逐行说明：

if (nums.length == 0) return 0;

空数组直接返回 0。

int slow = 0;

slow 指向不重复部分的末尾。第一个元素一定不重复，从 0 开始。

for (int fast = 1; fast < nums.length; fast++) {

fast 从第二个元素开始，快速扫描整个数组。

if (nums[fast] != nums[slow]) {

slow++;

nums[slow] = nums[fast];

}

如果 fast 遇到和 slow 不同的值，说明是新元素：

• slow++：slow 前进一步
• nums[slow] = nums[fast]：把新元素放到不重复部分的末尾

如果相同，什么都不做，fast 继续往前走。

return slow + 1;

slow 是下标（从 0 开始），所以唯一元素个数是 slow + 1。

---

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

fast	nums[fast]	slow	nums[slow]	不同?	操作	数组
-	-	0	0	-	-	[0,0,1,1,1,2,2,3,3,4]
1	0	0	0	否	跳过	同上
2	1	0	0	是	slow=1, nums[1]=1	[0,1,1,1,1,2,2,3,3,4]
3	1	1	1	否	跳过	同上
4	1	1	1	否	跳过	同上
5	2	1	1	是	slow=2, nums[2]=2	[0,1,2,1,1,2,2,3,3,4]
6	2	2	2	否	跳过	同上
7	3	2	2	是	slow=3, nums[3]=3	[0,1,2,3,1,2,2,3,3,4]
8	3	3	3	否	跳过	同上
9	4	3	3	是	slow=4, nums[4]=4	[0,1,2,3,4,...]

返回 slow + 1 = 5，前 5 个元素 [0,1,2,3,4] ✓

时间复杂度 O(n)，空间复杂度 O(1)。

---

Python 语言

class Solution(object):
    def removeDuplicates(self, 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

逻辑完全一致。区别：if not nums 判空，range(1, len(nums)) 遍历，slow += 1 自增。