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

〇、前言

上期回顾

        在上一节中我们讲到了数组的概念，以及数组的特征，其中有几个重要的概念。之后又讲到了数组的基本操作，创建和初始化、增删改查等，最后我们看了两个问题，单调数组和数组合并，并利用数组解决了他们。

本章内容

        在本篇文章中，我们接着来介绍一下数组的高级用法，数组中双指针的应用。接下来我将从什么是双指针思想？、双指针解决的具体问题实例讲解 两个方面进行讲解。

一、什么是双指针思想？

        顾名思义，双指针....双指针就是两个指针，当然在数组中，这里所谓的指针并不就是指针变量，只是代表两个数组中存储的基本变量。而双指针又分为两种类型：快慢双指针和对撞双指针。

1.快慢双指针

        所谓快慢双指针就是存在两个变量，并且两个同时从起点向后走，唯一的区别就是快指针走的比慢指针走的快。快指针先到终点。

2.对撞双指针

        所谓对撞双指针就是，存在两个指针变量，同时从数组的首端和尾端向数组中间走，最后碰到一起结束。

二、双指针的应用 

1.删除元素

        题目：给你一个数组 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先等待。 

代码：

    /**
     * 方法1：使用快慢型双指针
     */
    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的值。同时从首端和尾端进行遍历，当首端遇到val时停止，找到右边不是val的值来进行代替。

代码：

    /**
     * 方法二：对撞型双指针
     */
    public static int removeElement2(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.数组奇偶移动

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

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

根据题意，这种需要将相同的元素放到头部或者尾部，一般使用对撞双指针的方法，因为对撞双指针是从前后进行遍历的，方便交换元素等操作。

代码： 

    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;
    }

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 处分隔成左右两个部分，这里就是根据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);
    }

    public static 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;
        }
    }

第二种方法：直接反转

步骤：

1. 创建一个新的数组。
2. 当前位置的索引加上k取当前数组长度的余数 为新数组的索引。
3. 新数组索引等于数组的索引。

代码：

    public static int[] alter(int[] nums, int k) {
        int[] newArray = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            newArray[(i+k)% nums.length] = nums[i];
        }
        return newArray;
    }