双指针之同向指针--彻底解决删除重复性系列

转载leetcode某一大神：https://leetcode-cn.com/u/liuchuan1992/

双指针的题型，类似的题还有:
1. 删除排序数组中的重复元素
2. 移除元素
3. 快排
4. 归并
另外像快慢指针，滑动窗口其实也是同向指针，这里只看上面这一类题的通性是:同向指针，且其中一个指针是做循环使用的。

同向指针

同向指针很好理解，两个指针是相同方向的，类似于快慢指针求中点之类的。但不知道大家有没有这种感觉:思路很简单，写对却很难。各种条件稍有不慎全军覆没，感觉处处是坑，以至于内心写双指针是奔溃的，就跟之前写二分一样。
好了，说了那么多直接祭出神器吧！
循环不变量
简单来说,循环不变量指的是在写循环代码时，变量的值会随着循环的进行而变化，但变量的定义是必须保持不变的。
这玩意儿有什么好处呢？有的，他能帮你提高写代码的正确率！！！这里涉及到一个数学推理。

在使用循环的算法里，可以通过循环不变量证明其正确性。
所谓循环不变量是指一种在整个循环过程中保持不变的性质，它必须在以下3种情况下均保持不变，且该性质在循环终止后能证明算法的正确性。

初始化（循环的定义）
迭代（第 n 次迭代后，第 n+1 次迭代前）
结束（循环终止即循环条件判断为 false 时）
通俗点来说就是，只要你按照变量的定义严格保证变量在初始化，递归时，跳出循环时都保持不变的定义，那么就能证明你使用循环来推导问题是正确的。

同向指针解题步骤

这里还没有完全的整理所有的双指针，不敢妄自猜测会不会有不一般的情况。但这方法我觉得肯定是可以套用在所有的双指针问题上的，后续将继续更新双指针相关的题型。

解题步骤 (重点来了)

1. 定义指针 明确含义
2. 确定终止条件
3. 确定指针运动条件
4. 根据定义确定返回值

重点:循环不变量的初始、迭代、退出时保持定义一致。

实际操作：

一、删除排序数组中的重复项

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

示例 1:

给定数组 nums = [1,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。你不需要考虑数组中超出新长度后面的元素。

1、定义指针 明确指针的含义

这里定义了两个指针,index 与 i,其中i是隐式的放在循环体里的。
index:定义index表示不重复元素集合的右边界.用数学公式表示即[0,index)表示修改后的数组，因为左闭右开，所以index取不到
有了变量定义，按照循环不变量的要求，我们先要确定初始化的时候是严格遵守定义的。初始化时不重复元素为空, 因为左闭右开，所以index = 0的时候，[0,0)是空集，满足要求。

2、确定循环终止条件

如上面说的，这边还有个隐式的指针i(见代码),循环的终止条件就是i循环到数组的末尾。这类同向指针的题 其实都有这个特点，一个指针是循环指针，所以终止条件很简单。如果是对撞指针那么就会复杂些。类似于二分里面的left和right取不取等号

3、确定指针运动条件

根据index的定义:不重复的元素的右边界，那么当有新的不重复的元素需要加入时index将向右移动。

4、如何运动呢？

这任然跟指针的定义有关系，用循环不变量的话来说:就是你得在循环的时候保持变量的定义不变。因为这里我们定义不重复元素集合是[0,index)左闭右开，因此index这个下标是可以用来放新的不重复元素的。同时index++;保持下一个循环时任然是[0,index）左闭右开。

5、根据定义确定返回值

返回值是指新数组的长度，因为整个不重复元素集合是[0，index),即[0,index-1] 左闭右闭。因此一共有index-1 - 0 + 1个元素。

public int removeDuplicates(int[] nums) {
        // 1.定义[0,index)表示修改后的数组 即不重复的元素
        int index = 0; 
        // 2.终止条件
        for(int i = 0;i < nums.length;i++){
            // 3.指针运动条件
            if(index == 0 || nums[index-1] != nums[i]){
                nums[index] = nums[i];
                index++;
            }
        }
        // 4.根据定义确定返回值
        return index;
}

这里我们还可以对index变量进行修改:[0,index] 表示不重复元素集合，分析过程写在下面的代码里，大家可以自行分析看看。

    // 时间复杂度O(n) 空间复杂度O(1)
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length  == 0) return 0;
        // 1.指针定义 [0,index] 是修改后无重复的排序元素 注意 这里已经把0纳入进去了
        int index = 0;
        // 2.另一个循环指针 从1开始，终止为nums.length，为什么从1开始 因为我们要比较重复 nums[0] 肯定是不重复的
        for(int i = 1;i < nums.length;i++){
            // 3.指针运动的条件
            if(nums[index] != nums[i]){
                index++;
                nums[index] = nums[i];
            }
        }
        // 4.根据定义确定返回值
        return index + 1;
    }

二、删除排序数组中的重复项 II

题目：给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定 nums = [1,1,1,2,2,3]，函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,0,1,1,1,1,2,3,3]，函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。你不需要考虑数组中超出新长度后面的元素。

解：其实就是对于指针运动条件的考量，什么时候需要移动index指针?
1.nums[i] != nums[index] 表示当前遍历的位置i和不重复集合的右边界不一样，那么肯定能放入不重复集合了。
2.题目要求每个元素最多出现k次,那么如果nums[i] != nums[index-k+1] 就可以保证不会存在连续的k个元素是值是重复的。

    public static int removeDuplicates(int[] nums) {
        if(nums == null) return 0;
        if(nums.length <= 2) return nums.length;

        // 1.定义[0,index] 是修改后的满足要求的数组区间,这里已经把0 1 2 ...k- 1 ,共k个数 放进去了
        int index = 2;
        // 2.判断终止条件
        for(int i = 2;i < nums.length;i++){
            // 3.指针移动条件
            if(nums[i] != nums[index-2]){
                nums[index++] = nums[i];
            }
        }
        // 4.判断返回值
        return index;
    }

由此可以扩展一下，如果题目要求每个元素最多出现k次代码怎么写

public int removeDuplicates(int[] nums,int k) {
        if(nums == null) return 0;
        if(nums.length <= k) return nums.length;
        
        // 1.定义[0,index] 是修改后的满足要求的数组区间,这里已经把0 1 2 ...k- 1 ,共k个数 放进去了
        int index = k - 1;
        // 2.判断终止条件
        for(int i = k;i < nums.length;i++){
            // 3.指针移动条件
            if(nums[i] != nums[index-k+1]){
                index++;
                nums[index] = nums[i];
            }
        }
        // 4.判断返回值
        return index + 1;
    }

三、移动零

题目：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

代码如下：

   public void moveZeroes(int[] nums) {
        int k = 0;
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] != 0) {
                if (i != k) {
                    nums[k] = nums[i];
                    nums[i] = 0;
                }
                k++;
            }
        }  
    }

四、移除元素

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

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。
示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

代码如下：

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