代码随想录—力扣算法题：27移除元素.Java版（示例代码与导图详解）

版本说明

当前版本号[20230816]。

版本	修改说明
20230804	初版
20230816	优化了思路及代码注释

目录

27. 移除元素

力扣题目链接
更多内容可点击此处跳转到代码随想录，看原版文件

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

你不需要考虑数组中超出新长度后面的元素。

思路

数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

暴力解法

这个题目暴力的解法就是两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组。

删除过程如下：当nums=[1,2,3,4,1,2]，删除元素3

第一步：从下标为0开始向右查找，直到找到元素为3的下标

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FqityOJL-1692171942221)(https://gitee.com/YardonYan/imgs/raw/master/img/202308041749313.png)]

第二步：当找到元素为3的下标，将其删除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0eoH2WKO-1692171942222)(https://gitee.com/YardonYan/imgs/raw/master/img/202308041751899.png)]

第三步：删除完后，后面数组的元素就会往前靠了，最后一个元素除了向前靠，也会待在原位一个

很明显暴力解法的时间复杂度是O(n^2)，这道题目暴力解法在leetcode上是可以过的。

对应的java代码如下：

class Solution {
    public int removeElement(int[] nums, int val) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--;  // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--;  // 此时数组的大小-1
            }
        }
        return size;
    }
}

• 时间复杂度：O(n^2)

• 空间复杂度：O(1)

双指针法

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

很多同学这道题目做的很懵，就是不理解 快慢指针 究竟都是什么含义，所以一定要明确含义，后面的思路就更容易理解了。

删除过程如下：当nums=[1,2,3,4,1,2]，删除元素3

第一步：从下标为0开始向右查找，直到找到元素为3的下标

第二步：两个指针共同找到元素为3的下标后，快指针会先向右移动，将元素为3的值删除，同时把后面的元素往前移

第三步：继续往下走，走至最后，最后一位依旧保留原来的数字

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。

后续都会一一介绍到，本题Java代码如下：

public static int removeElement(int[] nums, int val) {
    // 使用快慢指针的方法
    int slowIndex = 0; // 慢指针索引，指向当前元素要填充的位置
    for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
        if (nums[fastIndex] != val) {
            nums[slowIndex] = nums[fastIndex]; // 将不等于指定值的元素放到慢指针指向的位置
            slowIndex++; // 慢指针向后移动一位
        }
    }
    return slowIndex; // 返回新数组的长度
}

注意这些实现方法并没有改变元素的相对位置！

• 时间复杂度：O(n)
• 空间复杂度：O(1)

两个方法的区别

暴力解法和双指针解法的主要区别在于时间复杂度和实现思路上。

暴力解法的思路是遍历整个数组，当发现需要移除的元素时，将数组中的所有元素向前移动一位，以覆盖需要移除的元素。这种解法的时间复杂度是O(n^2)，其中n是数组的长度。因为每次移动元素都需要遍历数组的剩余部分，最坏情况下需要移动n次。

双指针解法的思路是使用两个指针，一个指针用于遍历数组，另一个指针用于指示下一个非目标元素要存储的位置。双指针解法的时间复杂度是O(n)，其中n是数组的长度。因为遍历数组只需要进行一次，每个元素最多被访问两次。

综上所述，双指针解法比暴力解法具有更优的时间复杂度，并且不需要频繁移动数组中的元素，因此是更高效的解法。

总结

双指针法要点

定义两个指针：快指针和慢指针。

快指针用于遍历数组，慢指针用于指示当前非目标元素的位置。

具体步骤如下：

1. 初始化快指针和慢指针，都指向数组的起始位置。
2. 遍历数组，当快指针指向的元素等于目标值时，快指针向后移动一位；否则，将快指针指向的元素复制到慢指针的位置，并同时将快指针和慢指针都向后移动一位。
3. 重复步骤2，直到快指针遍历完整个数组。
4. 返回慢指针的位置作为新数组的长度。

测试代码如下：

package shuzhu;

public class Day02 {
    public static int removeElement(int[] nums, int val) {
        // 快慢指针
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }

    public static void main(String[] args) {
        int[] nums = {1,2,3,4,3,6};
        int val = 3;
        int result = removeElement(nums,val);
        System.out.println("当移除指定元素后，返回新的数组长度为："+result);
    }
}
 void main(String[] args) {
        int[] nums = {1,2,3,4,3,6};
        int val = 3;
        int result = removeElement(nums,val);
        System.out.println("当移除指定元素后，返回新的数组长度为："+result);
    }
}