移除元素算法-优快云博客

移除元素

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

原地修改：不能使用额外的数组空间。
元素顺序可以改变：对数组中剩余元素的顺序没有要求。
返回值：新的数组长度 k，其中前 k 个元素为不等于 val 的元素。

示例

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：函数返回的 k = 2，nums 的前两个元素为 2。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,3,0,4,_,_,_]
解释：函数返回的 k = 5，nums 的前五个元素可以是 0、1、3、0、4，顺序不重要。

解题思路

由于需要原地移除元素，并且元素的顺序可以改变，我们可以使用双指针方法来解决这个问题。

指针 k：表示当前不等于 val 的元素的插入位置，也是最终返回的新数组长度。
遍历指针 i：用于遍历整个数组。

算法步骤：

初始化一个变量 k = 0，表示当前不等于 val 的元素个数。
遍历数组 nums：
- 如果 nums[i] 不等于 val，则将 nums[i] 赋值给 nums[k]，并递增 k。
- 如果 nums[i] 等于 val，则跳过，不做任何操作。
遍历结束后，nums 的前 k 个元素即为不等于 val 的元素。

代码详解

function removeElement(nums: number[], val: number): number {
    let k = 0; // 用于记录不等于 val 的元素个数
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== val) {
            nums[k] = nums[i]; // 将当前元素移到前面第 k 个位置
            k++; // 增加计数器
        }
        // 如果 nums[i] === val，什么都不做，直接跳过
    }
    return k; // 返回不等于 val 的元素个数
}

解释：

变量初始化：
- let k = 0;：初始化计数器 k，表示不等于 val 的元素数量。
遍历数组：
- for (let i = 0; i < nums.length; i++) { ... }：遍历数组的每个元素。
条件判断：
- if (nums[i] !== val) { ... }：检查当前元素是否不等于 val。
元素移动：
- nums[k] = nums[i];：将不等于 val 的元素移动到前面位置 k。
- k++;：更新计数器，准备存放下一个不等于 val 的元素。
返回结果：
- return k;：返回新的数组长度，即不等于 val 的元素个数。

示例演示

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

初始状态：
- nums = [0,1,2,2,3,0,4,2]
- k = 0
遍历过程：
1. i = 0：
  - nums[0] = 0，0 !== 2，所以：
  - nums[k] = nums[0]; （nums[0] 赋值给 nums[0]，无变化）
  - k = 1
2. i = 1：
  - nums[1] = 1，1 !== 2，所以：
  - nums[k] = nums[1]; （nums[1] 赋值给 nums[1]，无变化）
  - k = 2
3. i = 2：
  - nums[2] = 2，2 === 2，跳过
4. i = 3：
  - nums[3] = 2，2 === 2，跳过
5. i = 4：
  - nums[4] = 3，3 !== 2，所以：
  - nums[k] = nums[4]; （nums[2] 赋值为 3）
  - nums = [0,1,3,2,3,0,4,2]
  - k = 3
6. i = 5：
  - nums[5] = 0，0 !== 2，所以：
  - nums[k] = nums[5]; （nums[3] 赋值为 0）
  - nums = [0,1,3,0,3,0,4,2]
  - k = 4
7. i = 6：
  - nums[6] = 4，4 !== 2，所以：
  - nums[k] = nums[6]; （nums[4] 赋值为 4）
  - nums = [0,1,3,0,4,0,4,2]
  - k = 5
8. i = 7：
  - nums[7] = 2，2 === 2，跳过
结果：
- 返回 k = 5
- nums 的前 5 个元素为 [0,1,3,0,4]

时间和空间复杂度

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

总结

双指针法：利用一个快指针遍历数组，一个慢指针记录新数组的位置。
原地修改：不需要额外的数组空间，直接在 nums 上进行修改。
顺序无关：题目允许改变元素的顺序，但本解法保持了原有的元素顺序。

注意事项

题目要求：返回的不等于 val 的元素可以是任意顺序，但在本解法中，我们保持了元素的相对顺序。
测试用例：在评测时，可能需要对 nums 的前 k 个元素进行排序以通过断言检查，但根据题目描述，顺序并不重要。

扩展

如果题目要求可以改变元素的顺序，且希望进一步优化，可以使用首尾双指针的方法，在某些情况下可以减少操作次数。

示例代码：

function removeElement(nums: number[], val: number): number {
    let left = 0;
    let right = nums.length - 1;
    while (left <= right) {
        if (nums[left] === val) {
            nums[left] = nums[right];
            right--;
        } else {
            left++;
        }
    }
    return right + 1;
}