算法通关村——双指针的妙用

1. 删除元素

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

给你一个数组 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]

第一种: 快慢双指针

定义两个指针slow和fast, 初始值都为0。
slow之前的位置都是有效部分, fast表示当前要访问的元素。
遍历的时候, fast不断向后移动:

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

图示如下:

代码实现:

/**
 * 使用快慢型双指针
 *
 * @param nums
 * @param val
 * @return
 */
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];
        } 
    }
    return slow;
}

第二种: 对撞双指针

定义两个指针left和right, 初始值分别为0和数组长度减1。
遍历的时候, left不断向后移动, 如果nums[left]的值为val, left停下, right向左移动, 直到nums[right]不为val, 此时将nums[right]的值赋给nums[left], 覆盖掉原先的值。当left == right 时结束循环。

图示如下:

代码实现:

/**
 * 使用对撞型双指针
  *
  * @param nums
  * @param val
  * @return
  */
 public static int removeElement2(int[] nums, int val) {
     int left = 0;
     int right = nums.length - 1;
     while (left <= right) {
         if (nums[left] == val && nums[right] != val) {
             int temp = nums[left];
             nums[left] = nums[right];
             nums[right] = temp;
         }
         if (nums[left] != val) {
             left++;
         }
         if (nums[right] == val) {
             right--;
         }
     }
     return 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.2 删除有序数组中的重复项

给你一个有序数组 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和fast, 初始位置slow指向第一个元素, fast指向第二个元素。fast先走, 如果fast指向的元素值和slow不同, 则slow向前走一步, 并将fast指向的元素值赋值给slow指向的当前元素, 即nums[++slow] = nums[fast]。依次类推。

代码实现:

public static int removeDuplicates(int[] nums) {
   // slow表示放入新元素的位置, 索引为 0 的元素可以跳过
    int slow = 1, fast = 1;
    for (; fast < nums.length; fast++) {
        if (nums[fast] != nums[slow - 1]) {
            nums[slow] = nums[fast];
            slow++;
        }
    }
    return slow;
}

2. 元素奇偶移动

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

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

思路:
采用对撞型双指针。定义两个指针left和right, 初始位置为 0 和 arr.length - 1, left从 0 开始逐步检查每个位置是否为偶数, 如果是则跳过, 否则停下; right从右向左检查, 如果是奇数则跳过, 否则停下。然后交换array[left] 和 array[right], 之后再继续循环, 直到 left >= right。

代码实现:

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

3. 数组轮转

给你一个数组，将数组中的元素向右轮转 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 处分隔成两个数组: [7,6,5] 和 [4,3,2,1]
3. 最后将两个数组再次翻转得到 [5,6,7] 和 [1,2,3,4], 拼接成一起就是结果 [5,6,7,1,2,3,4]

代码实现:

public 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);
}
public void reverse(int[] nums, int start, int end) {
    while (start < end) {
        int temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
        start += 1;
        end -= 1;
    }
}

4. 数组的区间问题

给定一个无重复元素的有序整数数组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”

思路:

使用双指针, 慢指针指向每个区间的起始位置, 快指针从慢指针位置开始向后遍历直到不满足连续递增 ( 或快指针到达数组边界 ), 则当区间结束; 然后将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;
}