算法学习笔记——双指针的妙用

我们前面说过数组里的元素是紧紧靠在一起的，假如有空隙后面的元素就要整体向前移动。同样如果在中间位置插入元素，那么其后的元素都要整体向后移动。在后面可以看到很多算法题都需要多轮、大量移动元素，这就导致执行效率低下。如何解决该问题是数组算法的一个重要问题，其中一种非常好用的方式就是双指针思想。

🎯目标:

1. 理解双指针思想是如何工作的（快慢型和对撞型）
2. 理解双指针如何解决删除元素问题的
3. 理解双指针如何解决奇偶移动问题的
4. 理解双指针如何解决数组轮转问题的
5. 理解指针如何解决区间相关问题的
6. 理解双指针如何字符串替换问题的

1. 双指针思想

这里介绍一种简单但非常有效的方式——双指针。所谓的双指针其实就是两个变量，不一定真的是指针。双指针思想简单好用，在处理数组、字符串等场景下很常见。看个例子，从下面序列中删除重复元素[1,2,2,2,3,3,3,5,5,7,8]，重复元素只保留一个。删除之后的结果应该为[1,2,3,5,7,8]。我们可以在删除第一个2时将将其后面的元素整体向前移动一次，删除第二个2时再将其后的元素整体向前移动一次，处理后面的3和5都一样的情况，这就导致我们需要执行5次大量移动才能完成，效率太低。如果使用双指针可以方便的解决这个问题，如图：

首先我们定义两个指针slow、fast。slow表示当前位置之前的元素都是不重复的，而fast则一直向后找，直到找到与slow位置不一样的 ，找到之后就将slow向后移动一个位置，并将arr[fast]复制给arr[slow]，之后fast继续向后找，循环执行。找完之后slow以及之前的元素就都是单一的了。这样就可以只用一轮移动解决问题。

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

2. 删除元素专题

所谓算法，其实就是将一个问题改改条件多折腾，上面专题就是添加的变形，再来看几个删除的变形问题。

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

27. 移除元素 - 力扣（LeetCode）

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的元素的时候，如何避免反复向前移动呢？
本题可以使用双指针方式，而且还有三种，我们都看一下：

第一种：快慢双指针

整体思想就是2.1.1中介绍的双指针的图示的方式，定义两个指针slow和fast，初始值都是0。

Slow之前的位置都是有效部分，fast表示当前要访问的元素。

这样遍历的时候，fast不断向后移动：

• 如果nums[fast]的值不为val，则将其移动到nums[slow++]处。
• 如果nums[fast]的值为val，则fast继续向前移动，slow先等待。

图示如下：

这样，前半部分是有效部分，后半部分是无效部分。

public static int removeElement(int[] nums, int val) {
        int slow = 0;
        //fast充当了快指针的角色
        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 removeElement2(int[] nums, int val) {
    int right = nums.length - 1;
    int left = 0;
    for (left = 0; left <= right; ) {
        if ((nums[left] == val) && (nums[right] != val)) {
            int tmp = nums[left];
            nums[left] = nums[right];
            nums[right] = tmp;
        }
        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 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;
}

对撞型双指针的过程与后面要学习的快速排序是一个思路，快速排序要比较很多轮，而这里只执行了一轮，理解本题将非常有利于后面理解快速排序算法。
另外，我们可以发现快慢型双指针留下的元素顺序与原始序列中的是一致的，而在对撞型中元素的顺序和原来的可能不一样了。

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

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

本题使用双指针最方便，一个指针负责数组遍历，一个指向有效数组的最后一个位置。为了减少不必要的操作，我们做适当的调整，例如令slow=1，并且比较的对象换做nums[slow - 1]，代码如下：

public static int removeDuplicates(int[] nums) {
    // slow表示可以放入新元素的位置,索引为0的元素不用管
    int slow = 1;
    // 循环起到了快指针的作用
    for (int fast = 0; fast < nums.length; fast++) {
        if (nums[fast] != nums[slow - 1]) {
            nums[slow] = nums[fast];
            slow++;
        }
    }
    return slow;
}

3. 元素奇偶移动专题

根据某些条件移动元素也是一类常见的题目，例如排序本身就是在移动元素，这里看一个奇偶移动的问题。

905. 按奇偶排序数组 - 力扣（LeetCode）

LeetCode905，按奇偶排序数组。给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。你可以返回满足此条件的任何数组作为答案。

例如：
输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。

最直接的方式是使用一个临时数组，第一遍查找并将所有的偶数复制到新数组的前部分，第二遍查找并复制所有的奇数到数组后部分。这种方式实现比较简单，但是会面临面试官的灵魂之问："是否有空间复杂度为O(1)的"方法。
我们可以采用对撞型双指针的方法，图示与2.1中的对撞型基本一致，只不过比较的对象是奇数还是偶数。如下图所示：

维护两个指针 left=0 和 right=arr.length-1，left从0开始逐个检查每个位置是否为偶数，如果是则跳过，如果是奇数则停下来。然后right从右向左检查，如果是奇数则跳过偶数则停下来。然后交换array[left]和array[right]。之后再继续巡循环，直到left>=right。

public static int[] sortArrayByParity(int[] A) {
        int left = 0, right = A.length - 1;
        while (left < right) {
            if (A[left] % 2 > A[right] % 2) {
                int tmp = A[left];
                A[left] = A[right];
                A[right] = tmp;
            }

            if (A[left] % 2 == 0) left++;
            if (A[right] % 2 == 1) right--;
        }

        return A;
    }

你有没有发现这种解法与2.1里第二种解法对撞指针几乎一样，只是处理条件换了一下？因为这就是对撞型双指针的解题模板！

4. 数组轮转问题

189. 轮转数组 - 力扣（LeetCode）

先看题目要求，LeetCode189.给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

例如：
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

这个题怎么做呢?你是否想到可以逐次移动来实现？理论上可以，但是实现的时候会发现要处理的情况非常多，比较难搞。这里介绍一种简单的方法：两轮翻转。
方法如下：

1. 首先对整个数组实行翻转，例如 [1,2,3,4,5,6,7] 我们先将其整体翻转成[7,6,5,4,3,2,1]。
2. 从 k 处分隔成左右两个部分，这里就是根据k将其分成两组 [7,6,5] 和[4,3,2,1]。
3. 最后将两个再次翻转就得到[5,6,7] 和[1,2,3,4]，最终结果就是[5,6,7,1,2,3,4]

代码如下：

public static void rotate(int[] nums, int k) {
    k %= nums.length;
    reverse(nums, 0, nums.length - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, nums.length - 1);
}

private static void reverse(int[] nums, int start, int end) {
    while (start < end) {
        int temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
        start++;
        end--;
    }
}

5. 数组的区间专题

数组中表示的数据可能是连续的，也可能是不连续的，如果将连续的空间标记成一个区间，那么我们可以再造几道题，先看一个例子：

228. 汇总区间 - 力扣（LeetCode）

LeetCode228.给定一个无重复元素的有序整数数组nums。返回恰好覆盖数组中所有数字的最小有序区间范围列表。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。列表中的每个区间范围 [a,b] 应该按如下格式输出：“a->b” ，如果 a != b"a" ，如果 a == b

示例1：
输入：nums = [0,1,2,4,5,7]
输出：["0->2","4->5","7"]
解释：区间范围是：
[0,2] --> "0->2"
[4,5] --> "4->5"
[7,7] --> "7"
 
示例2：
输入：nums = [0,2,3,4,6,8,9]
输出：["0","2->4","6","8->9"]
解释：区间范围是：
[0,0] --> "0"
[2,4] --> "2->4"
[6,6] --> "6"
[8,9] --> "8->9"

这里题意有点难理解,它的意思是12345这样连续的子段就用1->5表示，如果中间断开了比如123567这样就表示为1->3,5->7

本题容易让人眼高手低，一眼就看出来结果，但是编程实现则很麻烦。这个题使用双指针也可以非常方便的处理，慢指针指向每个区间的起始位置，快指针从慢指针位置开始向后遍历直到不满足连续递增（或快指针达到数组边界），则当前区间结束；然后将 slow指向更新为 fast + 1，作为下一个区间的开始位置，fast继续向后遍历找下一个区间的结束位置，如此循环，直到输入数组遍历完毕。

public static List<String> summaryRanges(int[] nums) {
    List<String> res = new ArrayList<>();
    // slow 初始指向第 1 个区间的起始位置
    int slow = 0;
    for (int fast = 0; fast < nums.length; fast++) {
        // fast 向后遍历，直到不满足连续递增(即 nums[fast] + 1 != nums[fast + 1])
        // 或者 fast 达到数组边界，则当前连续递增区间 [slow, fast] 遍历完毕，将其写入结果列表。
        if (fast + 1 == nums.length || nums[fast] + 1 != nums[fast + 1]) {
            // 将当前区间 [slow, fast] 写入结果列表
            StringBuilder sb = new StringBuilder();
            sb.append(nums[slow]);
            if (slow != fast) {
                sb.append("->").append(nums[fast]);
            }
            res.add(sb.toString());
            // 将 slow 指向更新为 fast + 1，作为下一个区间的起始位置
            slow = fast + 1;
        }
    }
    return res;
}

这个实现的精华是"fast + 1 == nums.length || nums[fast] + 1 != nums[fast + 1]"，我们是用fast+1来进行比较的，如果使用fast比较也可以，但是实现起来会有些case一直过不了，不信你可以试一下。
拓展我们本着不嫌事大的原则，假如这里是要你在上面的情况反过来，找缺失的区间该怎么做呢？例如：

这是LeetCode163题

示例：
输入: nums = [0, 1, 3, 50, 75], lower = 0 和 upper = 99,
输出: ["2", "4->49", "51->74", "76->99"]

6. 字符串替换空格问题

这是剑指offer中的题目，出现频率也很高：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
首先要考虑用什么来存储字符串，如果是长度不可变的char数组，那么必须新申请一个更大的空间。如果使用长度可变的空间来管理原始数组，或者原始数组申请得足够大，这时候就可能要求你不能申请O(n)大小的空间，我们一个个看。
首先是如果长度不可变，我们必须新申请一个更大的空间，然后将原始数组中出现空格的位置直接替换成%20即可，代码如下：

public String replaceSpace(StringBuffer str) {
      String res="";
        for(int i=0;i<str.length();i++){
            char c=str.charAt(i);
            if(c==' ')
                res += "%20";
            else
                res += c;
        }
        return res;
}

对于第二种情况，我们首先想到的是从头到尾遍历整个字符串，遇到空格的时候就将其后面的元素向后移动2个位置，但是这样的问题在前面说过会导致后面的元素大量移动，时间复杂度为O(n^2)，执行的时候非常容易超时。

比较好的方式是可以先遍历一次字符串，这样可以统计出字符串中空格的总数，由此计算出替换之后字符串的长度，每替换一个空格，长度增加2，即替换之后的字符串长度为:

新串的长度=原来的长度+2*空格数目

接下来从字符串的尾部开始复制和替换，用两个指针fast和slow分别指向原始字符串和新字符串的末尾，然后：slow不动，向前移动fast：

• 若指向的不是空格，则将其复制到slow位置，然后fast和slow同时向前一步；
• 若fast指向的是空格，则在slow位置插入一个%20，fast则只移动一步。

循环执行上面两步，便可以完成替换。详细过程如下(c语言版本)：

public static String replaceSpace2(StringBuffer str) {
    if (str == null) {
        return null;
    }
    int numOfBlank = 0; // 空格的数量
    int len = str.length();
    for (int i = 0; i < len; i++) {
        if (str.charAt(i) == ' ') {
            numOfBlank++;
        }
    }
    int newLength = len + 2 * numOfBlank;
    str.setLength(newLength);
    int fast = len - 1;
    int slow = newLength - 1;

    while (fast >= 0 && slow > fast) {
        char c = str.charAt(fast);
        if (c == ' ') {
            fast--;
            str.setCharAt(slow--, '0');
            str.setCharAt(slow--, '2');
            str.setCharAt(slow--, '%');
        } else {
            str.setCharAt(slow, c);
            fast--;
            slow--;
        }
    }
    return str.toString();
}