27. 移除元素
题目描述
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。
假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
- 更改
nums数组，使nums的前k个元素包含不等于val的元素。 nums的其余元素和nums的大小并不重要。- 返回
k。
用户评测
评测机将使用以下代码测试您的解决方案：
java
int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
// 它以不等于 val 的值排序。
int k = removeElement(nums, val); // 调用你的实现
assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
assert nums[i] == expectedNums[i];
}如果所有的断言都通过，你的解决方案将会 通过。
示例
示例 1：
输入： nums = [3,2,2,3], val = 3
输出： 2, nums = [2,2,_,_]
解释： 你的函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
示例 2：
输入： nums = [0,1,2,2,3,0,4,2], val = 2
输出： 5, nums = [0,1,4,0,3,_,_,_]
解释： 你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
提示
0 <= nums.length <= 1000 <= nums[i] <= 500 <= val <= 100
题解
方法一：辅助列表法（额外空间 O(n)）
思路
创建一个辅助列表 list，遍历原数组 nums，将所有不等于 val 的元素依次加入列表中。同时将有效元素个数记录为 count。遍历完成后，再将列表中的元素依次复制回 nums 的前 count 个位置，最后返回 count。
这种方法最直观易懂，但需要额外的空间来存储有效元素。
复杂度分析
- 时间复杂度： O(n)，遍历数组两次，每次最多 n 个元素。
- 空间复杂度： O(n)，最坏情况下所有元素都不等于
val，辅助列表需要存储全部 n 个元素。
代码
java
class Solution {
public int removeElement(int[] nums, int val) {
// 辅助列表，用于暂存不等于 val 的元素
ArrayList<Integer> list = new ArrayList<>();
// 记录不等于 val 的元素个数
int count = 0;
// 第一次遍历：筛选出所有不等于 val 的元素
for (int i = 0; i < nums.length; i++) {
if (nums[i] != val) {
// 将有效元素加入列表
list.add(nums[i]);
count++;
}
}
// 第二次遍历：将列表中的有效元素复制回 nums 的前 count 个位置
for (int i = 0; i < list.size(); i++) {
nums[i] = list.get(i);
}
// 返回有效元素的个数
return count;
}
}方法二：左右双指针交换法（空间 O(1)）
思路
使用左右两个指针 l 和 r，分别从数组两端向中间移动：
- 如果右指针指向的元素等于
val，说明它本来就应该被移除，右指针直接左移。 - 如果左指针指向的元素等于
val，而右指针指向的元素不等于val，则将左右指针的元素交换，然后两个指针同时向中间移动。 - 如果左指针指向的元素不等于
val，说明它已经在正确位置，左指针直接右移。
最终左指针 l 的位置即为有效元素的个数。这种方法会改变元素的相对顺序。
复杂度分析
- 时间复杂度： O(n)，左右指针最多各遍历一次数组。
- 空间复杂度： O(1)，原地操作，无需额外空间。
代码
java
class Solution {
public int removeElement(int[] nums, int val) {
// 左指针从数组开头向右移动
int l = 0;
// 右指针从数组末尾向左移动
int r = nums.length - 1;
// 当左右指针未相遇时继续处理
while (l <= r) {
// 情况 1：右指针指向 val，继续向左寻找有效元素
if (nums[r] == val) {
r--;
}
// 情况2：左指针指向 val，右指针指向有效元素，交换两者
else if (nums[l] == val && nums[r] != val) {
int num = nums[r];
nums[r] = nums[l];
nums[l] = num;
l++;
r--;
}
// 情况3：左指针指向有效元素，已在正确位置，左指针右移
else {
l++;
}
}
// 循环结束时，l 的位置即为有效元素的个数
return l;
}
}图解示例
以 nums = [3,2,2,3], val = 3 为例：
初始状态：l=0, r=3
nums: [3, 2, 2, 3]
↑ ↑
l r
第1步：nums[l]=3==val, nums[r]=3==val，情况1：r--
nums: [3, 2, 2, 3]
↑ ↑
l r
第2步：nums[l]=3==val, nums[r]=2≠val，情况2：交换 nums[l] 和 nums[r]，l++, r--
nums: [2, 2, 3, 3]
↑ ↑
l r
第3步：nums[l]=2≠val，情况3：l++
nums: [2, 2, 3, 3]
↑
l
↑
r
第4步：l > r，循环结束，返回 l=2
最终结果：返回 2，nums 前 2 个元素为 [2, 2] 方法三：快慢指针法（最优解，空间 O(1)，保持顺序）
思路
使用快慢两个指针：
- 快指针
fast：负责遍历整个数组，寻找不等于val的有效元素。 - 慢指针
slow：指向下一个有效元素应该存放的位置。
当快指针找到一个不等于 val 的元素时，将其赋值给慢指针所在位置，然后慢指针右移一位。遍历完成后，慢指针 slow 的值即为有效元素的个数。
这种方法的优点是保持有效元素的相对顺序不变，且空间复杂度为 O(1)，是最优解法。
复杂度分析
- 时间复杂度： O(n)，快指针遍历整个数组一次。
- 空间复杂度： O(1)，原地操作，无需额外空间。
代码
java
class Solution {
public int removeElement(int[] nums, int val) {
// 慢指针：指向下一个有效元素应存放的位置
int slow = 0;
// 快指针：遍历整个数组
for (int fast = 0; fast < nums.length; fast++) {
// 当快指针找到不等于 val 的有效元素时
if (nums[fast] != val) {
// 将该元素放到慢指针位置
nums[slow] = nums[fast];
// 慢指针右移
slow++;
}
}
// 遍历结束后，slow 的值即为有效元素的个数
return slow;
}
}图解示例
以 nums = [0,1,2,2,3,0,4,2], val = 2 为例：
初始状态：slow=0, fast=0
nums: [0, 1, 2, 2, 3, 0, 4, 2]
↑
slow,fast
第1步：nums[fast]=0 ≠ 2，有效！nums[slow]=nums[fast]，slow++
nums: [0, 1, 2, 2, 3, 0, 4, 2]
↑ ↑
slow fast
第2步：nums[fast]=1 ≠ 2，有效！nums[slow]=nums[fast]，slow++
nums: [0, 1, 2, 2, 3, 0, 4, 2]
↑ ↑
slow fast
第3步：nums[fast]=2 == 2，跳过！fast++
nums: [0, 1, 2, 2, 3, 0, 4, 2]
↑ ↑
slow fast
第4步：nums[fast]=2 == 2，跳过！fast++
nums: [0, 1, 2, 2, 3, 0, 4, 2]
↑ ↑
slow fast
第5步：nums[fast]=3 ≠ 2，有效！nums[slow]=nums[fast]，slow++
nums: [0, 1, 3, 2, 3, 0, 4, 2]
↑ ↑
slow fast
第6步：nums[fast]=0 ≠ 2，有效！nums[slow]=nums[fast]，slow++
nums: [0, 1, 3, 0, 3, 0, 4, 2]
↑
slow
↑
fast
第7步：nums[fast]=4 ≠ 2，有效！nums[slow]=nums[fast]，slow++
nums: [0, 1, 3, 0, 4, 0, 4, 2]
↑
slow
↑
fast
第8步：nums[fast]=2 == 2，跳过！fast++，遍历结束
nums: [0, 1, 3, 0, 4, 0, 4, 2]
↑
slow
最终结果：返回 slow=5，nums 前 5 个元素为 [0, 1, 3, 0, 4] 三种方法对比
| 方法 | 时间复杂度 | 空间复杂度 | 是否保持顺序 | 适用场景 |
|---|---|---|---|---|
| 辅助列表法 | O(n) | O(n) | 是 | 代码最简单，适合对空间无要求的场景 |
| 左右双指针 | O(n) | O(1) | 否 | 不需要保持顺序，追求空间最优 |
| 快慢指针 | O(n) | O(1) | 是 | 最优解，兼顾空间效率和顺序保持 |