【ARTS】【LeetCode-27】移除元素

前言

仅做学习使用，侵删

什么是ARTS？

算法(Algorithm): 每周至少一道LeetCode算法题，加强编程训练和算法学习

阅读(Review)： 阅读并点评至少一篇英文技术文章，提高英文水平

技巧 (Tip)：学习至少一个技术技巧，总结、归纳日常工作中遇到的知识点

分享(Share)：分析一篇有关点和思考的技术文章，建立影响力，输出价值观

算法

力扣-27题

链接:27. 移除元素 - 力扣（LeetCode）

题目描述

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。
用户评测：

评测机将使用以下代码测试您的解决方案：

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 <= 100
0 <= nums[i] <= 50
0 <= val <= 100

前置知识

1. 数组操作：了解如何遍历数组、修改数组元素。

数组的基础知识可以看这里 程序员算法面试中，必须掌握的数组理论知识 (opens new window)

1. 双指针技巧：掌握使用两个指针来处理数组问题的方法，其中一个用于读取（遍历），另一个用于写入（记录有效位置）

双指针法（快慢指针法）是一种常见的算法技巧，主要用于处理链表、数组等问题。它通过使用两个指针（通常称为快指针和慢指针）来遍历数据结构，从而实现特定的功能或优化算法的效率。

基本原理

快慢指针法的核心思想是让两个指针以不同的速度移动。通常情况下：

• 慢指针每次移动一步；
• 快指针每次移动两步。

通过这种方式，快指针会比慢指针更快地到达数据结构的末尾，而慢指针则可以保持在一个相对稳定的位置。这种速度差可以用来解决一些特定的问题。

常见应用场景

1. 链表问题
   • 检测链表是否有环：如果链表有环，快指针和慢指针最终会在环内相遇。如果没有环，快指针会先到达链表的末尾。
   • 找到链表的中间节点：当快指针到达链表末尾时，慢指针正好位于链表的中间位置。
   • 反转链表：通过双指针法可以实现链表的原地反转。
2. 数组问题
   • 移除数组中的特定元素：使用快指针遍历数组，慢指针记录需要保留的元素位置。
   • 合并两个有序数组：通过双指针分别指向两个数组的起始位置，依次比较并合并。
3. 滑动窗口问题
   • 寻找满足条件的子数组：通过双指针表示窗口的左右边界，动态调整窗口大小以满足特定条件。

LeetCode常见问题：

1. 链表是否有环
2. 数组移除特定元素

优点

• 时间效率高：通常可以将时间复杂度从O(n²)优化到O(n)。
• 空间效率高：不需要额外的存储空间，直接在原数据结构上操作。

3.时间复杂度与空间复杂度：理解算法效率的重要性，尽量寻找线性时间和常数空间的解决方案。

不同的解法有不同的时间和空间复杂度。

解题方法

方法一:暴力求解

最简单也是最容易想到的方法

class Solution {
    public int removeElement(int[] nums, int val) {
    // 暴力法
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (nums[i] == val) {
                for (int j = i + 1; j < n; j++) {
                    nums[j - 1] = nums[j];
                }
                i--;
                n--;
            }
        }
        return n;
    }
}

代码分析

时间复杂度分析

1. 外层循环：外层循环从 i = 0 遍历到 n，每次循环检查数组中的元素是否等于目标值 val。
   • 最坏情况下，外层循环需要遍历整个数组，时间复杂度为 O(n)。
2. 内层循环：当找到一个等于 val 的元素时，内层循环会将该元素之后的所有元素向前移动一位。
   • 每次内层循环的执行次数取决于剩余数组的长度。例如，如果数组中有 k 个等于 val 的元素，且它们的位置分布较为分散，那么内层循环的总执行次数接近 O(n²)。
3. 总结：
   • 最坏情况下，外层循环和内层循环的组合导致总时间复杂度为 O(n²)。
   • 最好情况下（数组中没有等于 val 的元素），时间复杂度为 O(n)。

因此，这段代码的时间复杂度为 O(n²)。

空间复杂度分析

1. 原地操作：代码直接在原数组上进行操作，没有使用额外的存储空间。
2. 变量占用：除了输入数组 nums，代码中只使用了几个辅助变量（i、j、n），这些变量占用的空间是常数级别的。

因此，这段代码的空间复杂度为 O(1)。

总结

• 时间复杂度：O(n²)
• 最坏情况下，外层循环和内层循环的组合导致总时间复杂度为 O(n²)。
• 最好情况下（数组中没有等于 val 的元素），时间复杂度为 O(n)。
• 空间复杂度：O(1)

方法二：快慢指针法

代码随想录中的快慢指针定义：

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

代码随想录解法

class Solution {
    public 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;
    }
}

自己的解法:

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow = 0; // 慢指针，记录需要保留的元素位置
        for (int fast = 0; fast < nums.length; fast++) { // 快指针，遍历数组
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow; // slow 的值即为移除特定元素后的数组长度
    }
}

代码分析：

时间复杂度为 O(n)，空间复杂度仍为 O(1)

其他解法：

//相向双指针法
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
        while(left <= right) {
            if(nums[left] == val) { //left位置的元素需要移除
                //将right位置的元素移到left（覆盖），right位置移除
                nums[left] = nums[right];
                right--;
            }
            left++;
            while(right >= 0 && nums[right] == val) right--;
        }
        return left;
    }
}

// 相向双指针法（版本二）
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            if(nums[left] == val){
                nums[left] = nums[right];
                right--;
            }else {
                // 这里兼容了right指针指向的值与val相等的情况
                left++;
            }
        }
        return left;
    }
}

参考资料：

1. 27. 移除元素 - 力扣（LeetCode）
2. 代码随想录