27. 移除元素

27. 移除元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //使用快慢指针
        int n = nums.size();
        int slow =0;
        for(int fast =0;fast<n;fast++){
            if(nums[fast] != val){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
};

好的，我会详细解释这段代码的逻辑，它使用了 双指针法 来实现原地修改数组，移除所有值等于 val 的元素。下面我们逐步分析每一行代码的作用：

代码：

for (int i = 0; i < nums.size(); i++) {
    if (nums[i] != val) {
        nums[k] = nums[i];  // 将不等于 val 的元素移到前面
        k++;  // 更新下一个可以存放不等于 val 的位置
    }
}

1. 外部循环：for (int i = 0; i < nums.size(); i++)

• 这里使用了一个 for 循环来遍历数组 nums 中的每个元素。i 是当前遍历到的元素的索引。
• i 从 0 开始，直到 nums.size()（数组的大小），也就是遍历整个数组。

2. 检查当前元素是否等于 val：if (nums[i] != val)

• 在每次遍历中，判断当前元素 nums[i] 是否不等于 val。
• 如果 nums[i] != val，说明该元素应该保留在数组中。也就是说，这个元素不等于要移除的元素，我们希望它继续存在并移到数组的前面。
• 如果 nums[i] == val，则跳过当前元素，不做任何操作，因为题目要求删除所有等于 val 的元素。

3. 将符合条件的元素放到数组前面：nums[k] = nums[i];

• 当当前元素 nums[i] 不等于 val 时，将它放到 nums[k] 位置。
• 这里的关键在于 k 的作用，k 是指向数组中下一个可以放置有效元素的位置。也就是说，k 标记着数组中不等于 val 的元素的个数，同时也指向下一个可以存放不等于 val 元素的位置。
• 这样，所有不等于 val 的元素都会依次被放到数组的前 k 个位置。

4. 更新 k 的值：k++;

• k 每次加 1，意味着下一个符合条件的元素应该存放在 nums[k] 的位置。
• 这样，k 会随着遍历逐渐增长，最终它的值表示数组中不等于 val 的元素的数量。

整体流程：

1. 初始化：

   • 假设数组 nums = {3, 2, 2, 3, 4, 5}，val = 3。
   • 初始化 k = 0，表示可以放置第一个不等于 val 的元素的位置。

2. 遍历数组：

   • 第一次遍历：i = 0，nums[0] = 3，它等于 val，所以跳过。
   • 第二次遍历：i = 1，nums[1] = 2，它不等于 val，所以将 nums[1] 移到 nums[0] 位置，nums 变成 {2, 2, 2, 3, 4, 5}，同时更新 k = 1。
   • 第三次遍历：i = 2，nums[2] = 2，它不等于 val，所以将 nums[2] 移到 nums[1] 位置，nums 变成 {2, 2, 2, 3, 4, 5}，同时更新 k = 2。
   • 第四次遍历：i = 3，nums[3] = 3，它等于 val，所以跳过。
   • 第五次遍历：i = 4，nums[4] = 4，它不等于 val，所以将 nums[4] 移到 nums[2] 位置，nums 变成 {2, 2, 4, 3, 4, 5}，同时更新 k = 3。
   • 第六次遍历：i = 5，nums[5] = 5，它不等于 val，所以将 nums[5] 移到 nums[3] 位置，nums 变成 {2, 2, 4, 5, 4, 5}，同时更新 k = 4。

3. 结束遍历：

   • 最终，数组的前 k 个位置保存了所有不等于 val 的元素：nums = {2, 2, 4, 5, _, _}，其中 _ 表示数组后面的部分不重要。
   • 返回 k = 4，即不等于 val 的元素数量。

结果：

最终，数组 nums 被修改为 nums = {2, 2, 4, 5, _, _}，返回 4。

总结：

• k 记录数组中不等于 val 的元素数量。
• k 同时也指向下一个可以放置不等于 val 元素的位置。
• 通过 nums[k] = nums[i]，我们将所有不等于 val 的元素移到数组的前面，最终返回 k，表示有效元素的数量。
• 这种方式是 原地 修改数组，空间复杂度是 O(1)，且时间复杂度是 O(n)，因为只需要一次遍历。

这种做法既高效又符合题目要求，不需要额外的空间来存储结果。