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

原地移除所有数值等于 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指针，让fast指针不断向后移动，如果当前循环如果fast指针指向的值不等于val，就将fast指针指向的值给复制到当前slow指针所指向的值，并且slow指针往后移动一格，当fast指针指向的值为val，则停止slow指针的移动，并且继续移动fast指针

总的来说，fast指针一直向后遍历，然后slow指针的作用就是代表slow之前的所有值，均没有val，类似于slow之前删除了val值，最后返回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;
}

第二种就是双指针对撞法

双指针对撞法，就是仍然定义双指针，只是用法在上述的基础上进行了改变。

首先仍然是定义slow和fast指针，但是slow指针是从前面开始指向的，而fast指针是从后面开始指向的。

slow指针不断往后走，当slow指针指向的值为val，即停止移动，并开始从后往前移动fast指针，当fast指针指向的值不为val，则将fast所指向的值赋值给slow，然后slow继续向后遍历

 

public int removeElement(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 ;
}

 

元素奇偶移动专题

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

例如：

输入：[3,1,2,4]

输出：[2,4,3,1]

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

最直接的方式是使用一个临时数组，第一遍查找并将所有的偶数复制到新数组的前部分，第二遍查找并复制所有的奇数到数组后部分。这种方式实现比较简单，但是会面临面试官的灵魂之问："是否有空间复杂度为O(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;
}

数组轮转问题

给你一个数组，将数组中的元素向右轮转 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 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;
    }
}

数组的区间专题

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

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

字符串替换空格问题

请实现一个函数，将一个字符串中的每个空格替换成“%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则只移动一步。 循环执行上面两步，便可以完成替换。详细过程如下：

public  String replaceSpace(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++;
    }
    str.setLength(len + 2 * numOfblank); //设置长度
    int fast = len - 1;  //两个指针
    int slow = (len + 2 * numOfblank) - 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();
}