LeetCode 27.移除元素

LeetCode 27.移除元素

1、题目

力扣题目链接：27. 移除元素

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

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

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入： nums = [3,2,2,3], val = 3
输出： 2, nums = [2,2]
解释： 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入： nums = [0,1,2,2,3,0,4,2], val = 2
输出： 5, nums = [0,1,3,0,4]
解释： 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

2、暴力法

思路：

这个题目的暴力解法是用两层 for 循环。

1. 获取输入数组 nums 的初始大小 size；
2. 外层的 for 循环用来遍历数组元素；
3. 在循环内部，检查当前元素 nums[i] 是否等于 val；

• 内层的 for 循环用来更新数组；
• 如果等于 val，则需要将 i+1 位置及其后面的所有元素向前移动一位，覆盖掉当前的 val；
• 完成移动后，由于数组中已经移除了一个元素，所以需要将 i 指针回退一位（i--），以便在下一次循环中跳过新移动到当前位置的元素。同时，更新 size 的值（size--），表示数组的新大小；

4. 当所有元素都被检查和处理后，循环结束，此时 size 变量的值就是移除所有 val 元素后数组的新长度。
5. 函数返回 size，即新数组的长度。

代码：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { // 如果当前元素等于指定值，将数组中i+1位置及其后面的元素向前移动一位 
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 由于数组整体前移一位，下标i也向前移动一位，以便下次正确遍历
                size--; // 更新数组大小，表示已经移除一个元素
            }
        }
        return size;
    }
};

复杂度分析

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

3、双指针法（单向遍历）

思路：

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

定义快慢指针

• 快指针：指向当前将要处理的元素，用于遍历整个数组。
• 慢指针：指向当前需要插入元素的位置（存放不等于 val 的元素的位置。）。

题目中要求删除数组中等于 val 的元素，因此输出数组的长度一定小于等于输入数组的长度，我们可以把输出的数组直接写在输入数组上。可以使用双指针法。

如果快指针指向的元素不等于 val，它一定是新数组的一个元素，我们就将快指针指向的元素复制到慢指针位置，然后将快慢指针同时右移；

如果快指针指向的元素等于 val，它不能在新数组里，此时慢指针不动，快指针右移一位。

整个过程保持不变的性质是：区间 [0,slowIndex) 中的元素都不等于 val。当快慢指针遍历完整个数组以后，slowIndex 的值就是新数组的长度。

这样的算法在最坏情况下（原数组中没有元素等于 val），快慢指针各遍历了数组一次。

代码：

class Solution {  
public:  
    int removeElement(vector<int>& nums, int val) {  
        int slowIndex = 0; // slowIndex指向当前需要插入元素的位置  
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) { // fastIndex用于遍历数组  
            if (nums[fastIndex] != val) { // 如果当前元素不等于指定值  
                nums[slowIndex++] = nums[fastIndex]; // 将该元素复制到slowIndex位置，并将slowIndex向后移动一位  
            }  
        }  
        return slowIndex; // 返回新的数组长度  
    }  
};

复杂度分析

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

4、双指针法（相向）（左闭右闭区间）

思路：

如果要移除的元素恰好在数组的开头，例如序列 [1,2,3,4,5]，当 val 为 1 时，我们需要把每一个元素都左移一位。题目中说：元素的顺序可以改变。实际上我们可以直接将最后一个元素 5 移动到数组开头，取代元素 1。这个优化在 val 元素的数量较少时非常有效。

我们可以使用两个指针从数组的两端同时向中间遍历，当找到等于给定值 val 的元素时，尝试将其与另一端的元素进行交换，以便将等于 val 的元素逐渐 聚集 到数组的一侧，并同时缩小搜索的范围。最终，返回左指针 left 的位置作为新数组的长度，因为所有不等于 val 的元素都将位于 left 指针的左侧。

1. 初始化左指针 left 指向数组起始位置，右指针 right 指向数组末尾位置。
2. 使用一个 while 循环，当 left 小于等于 right 时继续遍历。这意味着当两个指针没有相遇时，循环将持续执行。
3. 在循环内部，进行以下操作：
   • 如果 nums[left] 不等于 val，则 left 向右移动一位，继续检查下一个元素。
   • 如果 nums[right] 等于 val，则 right 向左移动一位，继续检查前一个元素。
   • 如果 nums[left] 等于 val 且 nums[right] 不等于 val，则交换 nums[left] 和 nums[right] 的值，并将 left 向右移动一位，right 向左移动一位。这样，等于 val 的元素就被移到了数组的右侧，同时不等于 val 的元素被移到了左侧。
4. left 指针在 right 指针的右侧时，循环结束。此时，left 指针指向的位置是最后一个有效元素的下一个位置，即 left 之前的所有元素都是不等于 val 的元素，新数组的长度就是 left。

这种方法两个指针在最坏的情况下合起来只遍历了数组一次。与单向遍历的双指针不同的是，双向遍历的双指针避免了需要保留的元素的重复赋值操作。

代码：

class Solution {  
public:  
    int removeElement(vector<int>& nums, int val) {  
        int left = 0; // 定义左指针left，指向数组起始位置
        int right = nums.size() - 1; // 定义右指针right，指向数组末尾位置
        while (left <= right) {   // 使用双指针从数组两端向中间遍历
            if (nums[left] != val) { // 如果left所指元素不等于val，将left向右移动一位
                ++left;
            } else if (nums[right] == val) { // 如果right所指元素等于val，将right向左移动一位
                --right; 
            } else { // 否则，交换左右指针所指的元素，并分别移动左右指针
                swap(nums[left], nums[right]);
                ++left;
                --right;
            }  
        }  
        return left; // 返回移除后的数组长度
        // return right + 1;
    }  
};

复杂度分析

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

5、双指针法（相向）（左闭右开区间）

代码：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int left = 0;
        int right = nums.size();
        while (left < right) {
            if (nums[left] != val) {
                ++left;
            } else if (nums[right - 1] == val) {
                --right;
            } else {
                swap(nums[left], nums[right - 1]);
                ++left;
                --right;
            }
        }
        return left;
    }
};

复杂度分析

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