算法通关村——双指针的妙用(删除数组中的元素)

双指针是解决数组元素删除问题的有力工具，常用的双指针包括三种类型：

一个在前(slow)一个在后(fast)的方式称为快慢指针，有些场景需要从两端向中间走，这种就称为对撞型指针或者相向指针，很多题目也会用到，我们接下来会看到很多相关的算法题。 还有一种比较少见的背向型，就是从中间向两边走。这三种类型其实非常简单，看的只是两个指针是一起向前走（相亲相爱一起走），还是从两头向中间走（冲破千难万险来爱你），还是从中间向两头走（缘分已尽，就此拜拜）。

现在我们通过两道题目来看看双指针是如何使用的：

原地移除所有数值等于 val 的元素

LeetCode27.给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。要求：不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

例子1:

输入：nums = [3,2,2,3], val = 3

输出：2, nums = [2,2] 例子2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2

输出：5, nums = [0,1,4,0,3]

 在删除的时候，从删除位置开始的所有元素都要向前移动，所以这题的关键是如果有很多值为val的元素的时候，如何避免反复向前移动呢？

本题我们提供三种双指针的解决方法：

第一种：快慢双指针

我们定义两个指针，slow和fast，都初始化为0。slow位置之前都是有效部分，fast表示当前要访问的元素。

遍历遵循以下规则：

当num[fast]不等于val时，则将其值赋值给num[slow++];

当num[fast]等于val时，则fast继续往前走，slow先停下来等待。

如下图：

 这样，slow前半段为有效部分，后半段为无效部分。

/**
     * 方法1：使用快慢型双指针
     *
     * @param nums
     * @param val
     * @return
     */
    public static 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;
    }

第二种：对撞双指针

对撞指针，有的地方叫做交换移除，核心思想是从右侧找到不是val的值来顶替左侧是val的值。什么意思呢？我们看图，我们以nums = [0,1,2,2,3,0,4,2], val = 2为例：

 上图比较清晰地说明了对撞双指针的基本实现，简单进行讲解：

定义两个指针，left初始化为0，right初始化为 数组长度+1；

当left为val 并且right不为val时，将right的值赋给left;

当left不等于val时，left向前移动；

当right等于val时，right向后移动；

当left==right时，left左侧就是删除val的所有元素了(值得注意的是该方法实现后数组是无序的)

  /**
     * 方法2：使用对撞型双指针
     *
     * @param nums
     * @param val
     * @return
     */
 public static int removeElement2(int[] nums, int val) {
         int right = nums.length - 1;
         int left = 0;
         for (left = 0; left <= right; ) {
         //若left处元素等于val并且right处元素不等于val，则left,right处元素互换
         if ((nums[left] == val) && (nums[right] != val)) {
             int tmp = nums[left];
             nums[left] = nums[right];
             nums[right] = tmp;
         }
         //后面的两种判断都可保证交换后，使left和right都继续移动
         //若left处元素不等于val时，则后移
         if (nums[left] != val) left++;
         //若right处元素不为val，则前移
         if (nums[right] == val) right--;
         }
         return left ;
    }

第三种：“对撞双指针+覆盖”法

当nums[left]等于val的时候，我们就将nums[right]位置的元素覆盖nums[left]，继续循环，如果nums[left]等于val就继续覆盖，否则才让left++，(这里想想为什么这样写也可以)这也是双指针方法的方法，实现代码：

/**
     * 方法三：优化对撞型双指针
     * 对撞双指针+覆盖法
     * @param nums
     * @param val
     * @return
     */
    public static int removeElement3(int[] nums, int val) {
        int right = nums.length - 1;
        for (int left = 0; left <= right; ) {
            if (nums[left] == val){
                nums[left] = nums[right];
                right--;
            } else {
                left++;
            }
        }
        return right + 1;
    }

删除有序数组中的重复项

LeetCode26 给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例1：

输入：nums = [1,1,2]

输出：2, nums = [1,2]

解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

 例子2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]

输出：5, nums = [0,1,2,3,4]

解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

本题使用双指针的方法较为方便，参考 上述上一题目的快慢指针法：

public static int removeDuplicates(int[] nums) {
        //slow表示可以放入新元素的位置，索引为0的元素不用管
        int slow = 1;
        //循环起到了快指针的作用
        for (int fast = 1; fast < nums.length; fast++) {
            if (nums[fast] != nums[slow - 1]) {//当fast与slow前一元素不同时
                nums[slow] = nums[fast];//就将fast赋值给slow
                slow++;//slow向后移动
            }
        }
        return slow;
    }