数组---双指针思想+删除元素专题

双指针思想以及应用（一）

---

1. 双指针思想

所谓双指针其实就是两个变量，并不一定真的是指针。双指针思想在处理数组、字符串等场景下很常见。
看一个例子，从下面序列中删除重复元素。
[1,2,2,2,3,3,3,5,5,7,8]，重复元素只保留一个。结果应该是[1,2,3,5,7,8]。这里用双指针可以很方便的解决这个问题，相比于将元素一个一个向前移动的方式效率高了很多，如图：

步骤：

1. 定义两个指针slow 和 fast。 slow当前位置之前的元素都不是重复的，fast会一直向后移动直到fast的值与slow不同。
2. fast找到后，将slow向后移动一个位置。
3. 将arr[fast] 复制给 arr[slow]。
4. fast继续向后找，循环执行。找完之后slow以及之前的元素就都是单一的了。

上面提到的方式叫做快慢指针，有一些场景需要从两端向中间走，这种这种称为对撞型指针或者相向指针，接下来会看到很多相关题目

---

2. 删除元素专题

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

LeetCode27

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

不要使用额外的数组空间，你必须仅使用 O(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]，也会被视作正确答案。

解题方法1:快慢双指针

思路与直接介绍的一致，定义连个指针slow和fast，初始值都是0
slow之前位置是有效部分，fast表示当前要访问的元素
遍历时，fast不断向后移动：

• 如果nums[fast]值不为val，则将其移动到nums[slow++]处
• 如果nums[fast]值为val，则fast继续向前移动，slow先等待
  如图：
  
  注意我们只取slow往前的位置
  代码：

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 == right时，left以及左侧的就是删除掉2的所有元素了
代码：

public static int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length-1;

        for (left = 0; left <= right; ) {
            if ((nums[left] == val) && (nums[right] != val)) {
                nums[left] = nums[right];
            }
            if (nums[left] != val) left++;
            if (nums[right] == val) right--;
        }
        return left;
    }

拓展解题方法：对撞双指针 + 覆盖

当nums[left]等于val的时候，我们就将nums[right]位置的元素覆盖nums[left]，继续循环，如果nums[left]等于val就继续，否则才让left++
代码：

public static int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length-1;

        for (left = 0; left <= right;) {
            if (nums[left] == val) {
                nums[left] = nums[right];
                right--;
            } else {
                left++;
            }
        }
        return left;
    }

发现
快慢型双指针留下的元素顺序和原始顺序中是一致的
对撞型双指针留下的元素顺序和原始顺序可能就不一样了

---

2.2 删除有序数组中的重复项

LeetCode26.删除有序数组中的重复项
给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数，使用O(1)额外空间的条件下完成。
示例：

输入：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 。不需要考虑数组中超出新长度后面的元素。

思路依旧是双指针，一个负责数组遍历，一个指向有序数组的最后一个位置。这里为了方便我们直接让slow = 1，比较的对象为nums[slow - 1]，这样索引为0的元素我们就不用关心了。
代码：

public int removeDuplicates(int[] nums) {
        int slow = 1;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != nums[slow - 1]) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }

这里我画图给大家解析这段代码(以示例中的例子为例）

推荐读者朋友们自己画一下，更加清晰。