LeetCode刷题27-简单- 移除元素☀️ 前言 ☀️???? 作者简介 ???????? 一、题目描述 ???????? 二、题目解析 ???????? 三、代码 ???????? 结语 ????

65 阅读 0 评论 43 点赞

我是靠谱客的博主害怕溪流，最近开发中收集的这篇文章主要介绍LeetCode刷题27-简单- 移除元素☀️ 前言 ☀️???? 作者简介 ???????? 一、题目描述 ???????? 二、题目解析 ???????? 三、代码 ???????? 结语 ????，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

在这里插入图片描述

文章目录

☀️ 前言 ☀️
???? 作者简介 ????
???? 一、题目描述 ????
???? 二、题目解析 ????
???? 三、代码 ????
- ☁️ 1️⃣. python ☁️
- ⚡️ 2️⃣. java ⚡️
- ❄️ 3️⃣. C# ❄️
???? 结语 ????

☀️ 前言 ☀️

算法作为极其重要的一点，是大学生毕业找工作的核心竞争力，所以为了不落后与人，开始刷力扣算法题！

第一遍，不求最优解，但求能过！！！

???? 作者简介 ????

大家好，我是布小禅，一个尽力让无情的代码变得生动有趣的IT小白，很高兴能偶认识你，关注我，每天坚持学点东西，我们以后就是大佬啦！

???? 博客主页：❤布小禅❤
???? 作者专栏：
❤Python❤
❤Java❤

❤力扣题❤

这是我刷第 21/100 道力扣简单题

???? 一、题目描述 ????

给你一个数组 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,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

$提示 :$

$0 < = n u m s . l e n g t h < = 100$
$0 < = n u m s [i] < = 50$
$0 < = v a l < = 100$

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

???? 二、题目解析 ????

"""
  判断：
  当数组为空时的返回值
  当数组只有一个元素，且与目标值不等时的返回值
  当数组只有一个元素，且与目标值相等时的返回值
  使用双指针求解：
  一个指针跟随数组下标移动 i=0
  另一个指针从后往前移动  j=nums.length  
  遍历数组
    如果当前数组元素与目标值相等 
    从数组尾部倒着循环到当前下标
        不能使用j进行循环，赋予一个临时变量m=j-1
            如果元素值与val不等
                将元素值赋值给i下标，并结束当前循环
            如果相等
                就跳过，进入下一循环，令m--
        循环结束，将m的值赋值给j，j表示替换后的数组长度
    判断结束，更新变量i
  循环结束，返回j
"""

???? 三、代码 ????

现在的简单题就用三种语言，等后面的，就不用java了

☁️ 1️⃣. python ☁️

"""
  判断：
  当数组为空时的返回值
  当数组只有一个元素，且与目标值不等时的返回值
  当数组只有一个元素，且与目标值相等时的返回值
  使用双指针求解
  一个指针跟随数组下标移动 i=0
  另一个指针从后往前移动  j=nums.length  
  遍历数组
    如果当前数组元素与目标值相等 
    从数组尾部倒着循环到当前下标
        不能使用j进行循环，赋予一个临时变量m=j-1
            如果元素值与val不等
                将元素值赋值给i下标，并结束当前循环
            如果相等
                就跳过，进入下一循环，令m--
        循环结束，将m的值赋值给j，j表示替换后的数组长度
    判断结束，更新变量i
  循环结束，返回j
"""
class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        j=len(nums)                               # j指针从后往前移动  
        i= 0                                      # 指针跟随数组下标移动 i=0
        if j==0: return 0                         # 当数组为空时的返回值
        if j==1 and nums[0]!=val: return 1        # 当数组只有一个元素，且与目标值不等时的返回值
        if j==1 and nums[0]==val: return 0        # 当数组只有一个元素，且与目标值相等时的返回值
        while i<j:                                # 遍历数组
            if nums[i]==val:                      # 如果当前数组元素与目标值相等
                m = j-1                           # 赋予一个临时变量m
                while i<m:                        # 组尾部倒着循环到当前下标
                    if nums[m]!=val:              # 如果元素值与val不等
                        nums[i] = nums[m]         # 将元素值赋值给i下标，并结束当前循环
                        break                     # 结束当前循环
                    else: m-=1                    # 就跳过，进入下一循环，更新变量m
                j=m                               # 循环结束，将m的值赋值给j，j表示替换后的数组长度
            i+=1                                  # 判断结束，更新变量i
        return j                                  # 循环结束，返回j

⚡️ 2️⃣. java ⚡️

/**
  判断：
  当数组为空时的返回值
  当数组只有一个元素，且与目标值不等时的返回值
  当数组只有一个元素，且与目标值相等时的返回值
  使用双指针求解
  一个指针跟随数组下标移动 i=0
  另一个指针从后往前移动  j=nums.length  
  遍历数组
    如果当前数组元素与目标值相等 
    从数组尾部倒着循环到当前下标
        不能使用j进行循环，赋予一个临时变量m=j-1
            如果元素值与val不等
                将元素值赋值给i下标，并结束当前循环
            如果相等
                就跳过，进入下一循环，令m--
        循环结束，将m的值赋值给j，j表示替换后的数组长度
    判断结束，更新变量i
  循环结束，返回j
 */
class Solution {
    public int removeElement(int[] nums, int val) {
        int j=nums.length;                               // j指针从后往前移动  
        int i= 0;                                        // 指针跟随数组下标移动 i=0
        if (j==0) return 0;                              // 当数组为空时的返回值
        if(j==1&&nums[0]!=val) return 1;                 // 当数组只有一个元素，且与目标值不等时的返回值
        if(j==1&&nums[0]==val) return 0;                 // 当数组只有一个元素，且与目标值相等时的返回值
        while (i<j)                                      // 遍历数组
        {
            if (nums[i]==val)                            // 如果当前数组元素与目标值相等
            {
                int m = j-1;                             // 赋予一个临时变量m
                while(i<m)                               // 组尾部倒着循环到当前下标
                {
                    if(nums[m]!=val)                     // 如果元素值与val不等
                    {
                        nums[i] = nums[m];               // 将元素值赋值给i下标，并结束当前循环
                        break;                           // 结束当前循环
                    }else m--;                           // 就跳过，进入下一循环，更新变量m
                } 
                j=m;                                     // 循环结束，将m的值赋值给j，j表示替换后的数组长度
            }
            i++;                                         // 判断结束，更新变量i
        }
        return j;                                        // 循环结束，返回j
    }
}

❄️ 3️⃣. C# ❄️

/*
  判断：
  当数组为空时的返回值
  当数组只有一个元素，且与目标值不等时的返回值
  当数组只有一个元素，且与目标值相等时的返回值
  使用双指针求解
  一个指针跟随数组下标移动 i=0
  另一个指针从后往前移动  j=nums.length  
  遍历数组
    如果当前数组元素与目标值相等 
    从数组尾部倒着循环到当前下标
        不能使用j进行循环，赋予一个临时变量m=j-1
            如果元素值与val不等
                将元素值赋值给i下标，并结束当前循环
            如果相等
                就跳过，进入下一循环，令m--
        循环结束，将m的值赋值给j，j表示替换后的数组长度
    判断结束，更新变量i
  循环结束，返回j
*/
public class Solution {
    public int RemoveElement(int[] nums, int val) {
        int j=nums.Length;                               // j指针从后往前移动  
        int i= 0;                                        // 指针跟随数组下标移动 i=0
        if (j==0) return 0;                              // 当数组为空时的返回值
        if(j==1&&nums[0]!=val) return 1;                 // 当数组只有一个元素，且与目标值不等时的返回值
        if(j==1&&nums[0]==val) return 0;                 // 当数组只有一个元素，且与目标值相等时的返回值
        while (i<j)                                      // 遍历数组
        {
            if (nums[i]==val)                            // 如果当前数组元素与目标值相等
            {
                int m = j-1;                             // 赋予一个临时变量m
                while(i<m)                               // 组尾部倒着循环到当前下标
                {
                    if(nums[m]!=val)                     // 如果元素值与val不等
                    {
                        nums[i] = nums[m];               // 将元素值赋值给i下标，并结束当前循环
                        break;                           // 结束当前循环
                    }else m--;                           // 就跳过，进入下一循环，更新变量m
                } 
                j=m;                                     // 循环结束，将m的值赋值给j，j表示替换后的数组长度
            }
            i++;                                         // 判断结束，更新变量i
        }
        return j;                                        // 循环结束，返回j
    }
}