LeetBook-简单-26：删除有序数组中的重复项

LeetBook-简单-26：删除有序数组中的重复项

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

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

• 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
• 返回 k 。

判题标准:

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

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
• -104 <= nums[i] <= 104
• nums 已按 非严格递增 排列

方法一：使用ArrayList

解题思路

1. 使用动态数组：我们使用 ArrayList 来存储不重复的元素，因为它可以动态调整大小，方便我们在运行时添加新元素。
2. 遍历输入数组：从 nums 数组的第二个元素开始遍历。第一个元素直接添加到 list 中。
3. 检查重复性：
   • 对于每一个遍历到的元素，使用 list.contains(nums[i]) 方法检查该元素是否已经在 list 中。
   • 如果不在 list 中，则将该元素添加到 list 中。
4. 复制元素：遍历结束后，list 中将只包含不重复的元素。接下来，我们将 list 中的元素复制回原来的 nums 数组的前面部分。
5. 返回新数组的长度：最后，返回 list 的大小，作为去重后数组的长度。

public static int removeDuplicates(int[] nums) {
    // 创建一个 ArrayList 用于存储不重复的元素
    ArrayList<Integer> list = new ArrayList<>();
    
    // 将第一个元素添加到 list 中
    list.add(nums[0]);
    
    // 从第二个元素开始遍历 nums 数组
    for (int i = 1; i < nums.length; i++) {
        // 检查当前元素是否已经存在于 list 中
        if (!list.contains(nums[i])) {
            // 如果不存在，则将其添加到 list 中
            list.add(nums[i]);
        }
    }
    
    // 将 list 中的元素复制回原来的 nums 数组中
    for (int i = 0; i < list.size(); i++) {
        nums[i] = list.get(i);
    }
    
    // 返回去重后数组的长度
    return list.size();
}

复杂度分析

• 时间复杂度：O(n^2)，其中 n 是输入数组 nums 的长度。因为在最坏情况下，list.contains() 方法需要遍历整个 list，对于每个元素都要进行一次检查，所以整体复杂度为 O(n^2)。
• 空间复杂度：O(n)，因为我们使用了一个 ArrayList 来存储不重复的元素。

方法二：leetbook官方解题

解题思路

1. 指针初始化：

   • 使用两个指针：slow 和 fast。
   • slow 指针用于记录不重复元素的位置，初始值为 1（假设第一个元素总是保留）。
   • fast 指针用于遍历数组，初始值为 1，从第二个元素开始。

2. 遍历数组：

   • 当 fast 指针小于数组长度 n 时，进入循环。

   • 在循环中，比较

     nums[fast]和nums[fast - 1]

     • 如果这两个元素不同，说明找到了一个新的不重复元素。
     • 将 nums[fast] 的值赋给 nums[slow]，并将 slow 指针向右移动一位。

3. 继续移动 fast 指针：

   • 不论当前元素是否重复，fast 指针都会向右移动一位，继续检查下一个元素。

4. 返回结果：

   • 当 fast 指针遍历完整个数组后，返回 slow 的值，表示去重后数组的长度。

public int removeDuplicates(int[] nums) {
    // 获取数组的长度
    int n = nums.length;
    // 如果数组为空，直接返回 0
    if (n == 0) {
        return 0;
    }
    // 初始化两个指针，fast 用于遍历，slow 用于记录不重复元素的位置
    int fast = 1, slow = 1;
    // 当 fast 指针小于数组长度时，继续遍历
    while (fast < n) {
        // 如果当前元素与前一个元素不同，说明是一个新的不重复元素
        if (nums[fast] != nums[fast - 1]) {
            // 将不重复元素放到 slow 指针的位置
            nums[slow] = nums[fast];
            // 移动 slow 指针
            ++slow;
        }
        // 移动 fast 指针
        ++fast;
    }
    // 返回去重后数组的长度
    return slow;
}

• 时间复杂度：O(n)，其中 n 是数组的长度。因为每个元素只被访问一次。
• 空间复杂度：O(1)，只使用了常量级别的额外空间，不需要额外的数组或集合。

方法三：

解题思路：

1. 问题理解：
   • 给定一个已排序的数组 nums，要求去除重复元素，并返回新数组的长度。
   • 由于数组是排序的，重复的元素必然是相邻的。
2. 使用两个数组：
   • 创建一个新的数组 res 来存放不重复的元素。
   • 使用一个指针 p 来记录 res 中最后一个不重复元素的位置。
3. 遍历数组：
   • 从 nums 的第二个元素开始遍历，检查当前元素是否与 res 中最后一个不重复元素相同。
   • 如果不同，说明当前元素是一个新的不重复元素，将其添加到 res 中，并更新指针 p。
4. 复制结果：
   • 遍历完成后，将 res 中的元素复制回 nums 的前面部分。
5. 返回结果：
   • 最后，返回不重复元素的数量，即 p + 1。

class Solution {
    public int removeDuplicates(int[] nums) {
        // 创建一个新的数组 res，用于存放不重复的元素
        int res[] = new int[nums.length];
        
        // 指针 p 用于追踪 res 数组中最后一个不重复元素的位置
        int p = 0;
        
        // 将第一个元素直接赋值给 res[0]
        res[0] = nums[0];
        
        // 从第二个元素开始遍历 nums 数组
        for(int i = 1; i < nums.length; i++) {
            // 如果当前元素与 res 中最后一个不重复元素不同
            if(nums[i] != res[p]) {
                // 移动指针 p，指向下一个位置
                p++;
                // 将当前不重复的元素存入 res 数组
                res[p] = nums[i];
            }
        }
        
        // 将不重复的元素复制回原数组 nums
        for(int i = 0; i <= p; i++) {
            nums[i] = res[i];
        }
        
        // 返回不重复元素的数量
        return p + 1;
    }
}

• 时间复杂度： O(n)，其中 n 是数组的长度，因为我们只遍历了一遍数组。
• 空间复杂度： O(n)，因为我们使用了一个额外的数组 res。如果需要优化空间，可以考虑在原数组上进行操作，不使用额外的数组。