删除数组元素的经典案例题——leetcode27 移除数组 （五种方法详解，cpp，Java实现）

一道数组删除元素的题目，题目链接如下：

力扣

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

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

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

方法一：双指针法

这是一种常见的解题方法，我们可以使用两个指针，一个指针遍历数组，另一个指针记录非目标元素的个数。当遇到目标元素时，就跳过它，遇到非目标元素时，就与当前指针所指的元素交换位置。

CPP代码例子：

int removeElement(vector<int>& nums, int val) {
    int i = 0;
    for (int j = 0; j < nums.size(); ++j) {
        if (nums[j] != val) {
            nums[i++] = nums[j];
        }
    }
    return i;
}

Java代码例子：

public int removeElement(int[] nums, int val) {
    int i = 0;
    for (int j = 0; j < nums.length; ++j) {
        if (nums[j] != val) {
            nums[i++] = nums[j];
        }
    }
    return i;
}

方法二：双指针法优化

在方法一的基础上，我们可以稍作优化。当要删除的元素比较少时，我们可以将要删除的元素移到数组的末尾，减少了赋值的次数。

CPP代码例子：

int removeElement(vector<int>& nums, int val) {
    int i = 0;
    int n = nums.size();
    while (i < n) {
        if (nums[i] == val) {
            nums[i] = nums[n - 1];
            n--;
        } else {
            i++;
        }
    }
    return n;
}

Java代码例子：

public int removeElement(int[] nums, int val) {
    int i = 0;
    int n = nums.length;
    while (i < n) {
        if (nums[i] == val) {
            nums[i] = nums[n - 1];
            n--;
        } else {
            i++;
        }
    }
    return n;
}

双指针法优化相比于普通双指针法减少了赋值操作的次数。这个思想实际上就是“对撞双指针+覆盖”法。

方法三：逆序遍历法

这种方法比较巧妙，我们从后向前遍历数组，将要删除的目标元素直接从数组中删掉。这样就不需要频繁地搬移元素了哦~ 😏

CPP代码例子：

int removeElement(vector<int>& nums, int val) {
    int n = nums.size();
    for (int i = n - 1; i >= 0; --i) {
        if (nums[i] == val) {
            nums[i] = nums[n - 1];
            n--;
        }
    }
    return n;
}

Java代码例子：

public int removeElement(int[] nums, int val) {
    int n = nums.length;
    for (int i = n - 1; i >= 0; --i) {
        if (nums[i] == val) {
            nums[i] = nums[n - 1];
            n--;
        }
    }
    return n;
}

逆序遍历法不需要频繁地搬移元素。

方法四：快慢双指针

定义两个指针slow和fast，初始值都是0。
Slow之前的位置都是有效部分，fast表示当前要访问的元素。
slow表示当前位置之前的元素都是不重复的，而fast则一直向后找，直到找到与slow位置不一样的 ，找到之后就将slow向后移动一个位置，并将arr[fast]复制给arr[slow]，之后fast继续向后找，循环执行。找完之后slow以及之前的元素就都是单一的了。

CPP代码例子：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow=0;
        for(int i=0;i<nums.size();i++){//此处i相当于fast
            if(nums[i]!=val){
                nums[slow]=nums[i];
                slow++;
            }
        }
        return slow;
    }
};

Java代码例子：

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=val){
                nums[slow]=nums[i];
                slow++;
            }
        }
        return slow;
    }
}

效率很高，击败100%用户。

方法五：对撞双指针

从右侧找到不是val的值来顶替左侧是val的值。

CPP代码例子：

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

Java代码例子：

class Solution {
    public int removeElement(int[] nums, int val) {
        int left=0;
        int right=nums.length-1;//为什么长度要-1？（因为数组的下标是从0开始计数的）
        for(left=0;left<=right;){//为什么是left<=right？
            if((nums[left]==val)&&(nums[right]!=val)){//没有括号可以吗？（完全可以）
                int t=nums[left];//为什么要设中间变量t？（暂存左右指针所指向的元素，方便交换操作）
                nums[left]=nums[right];
                nums[right]=t;
            }
            if (nums[left] != val) left++;
            if (nums[right] == val) right--;
        }
        return left;
    }
}

【为什么left<=right？】

在这个代码中，使用了双指针的方法来删除数组中等于给定值 val 的元素。left 和 right 分别指向数组的头和尾。在算法执行过程中，左指针 left 从左往右扫描，右指针 right 从右往左扫描。当左右指针都扫描完数组时，算法结束。

left<=right 的条件是循环控制条件，保证 left 指针不会超过 right 指针。如果 left > right，就说明扫描数组结束，所有元素都被处理过了。

因此，当 left 指针和 right 指针重合时，还需要让 left 指针再移动一次，才能保证最终得到的数组是正确的。

另外，快慢型双指针留下的元素顺序与原始序列中的是一致的，而在对撞型中元素的顺序和原来的可能不一样了。