LeetCode(Java)经典题之双指针法(26、27、283、844、977)

快慢指针到底是个啥捏，别急，先看27题：

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

想起来好像挺容易的，找到要删除的val，把对应数组里的值删掉就好了。可是数组的元素在内存地址中是连续的，没有办法进行删除操作，只能进行覆盖。

为了完成题目要求的操作，我们采用快慢指针（双指针）的方法，具体的过程借用《代码随想录》里面的动图进行展示：

为了实现这整个过程，我们需要定义fastIndex和slowIndex，fastIndex找到val时，移动到后一个元素，把后一个元素的值覆盖到val上(即nums[slowIndex])，此后继续遍历，slowIndex后移。

具体代码实现过程如下：

public class question27 {
    public int removeElement(int[] nums, int val) {
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0;fastIndex < nums.length;fastIndex++){
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }
}

趁热打铁，我们看第26题：

给你一个 升序排列的数组nums,请你原地删除重复出现的元素，
使每个元素只出现一次,返回删除后数组的新长度.元素的相对顺序应该保持一致 。
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。
更规范地说，如果在删除重复项之后有k个元素,那么nums的前k个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

这一题和27题十分类似，由于快指针始终比满指针走得快，所以在快指针遍历到和慢指针相同元素的时候， 快指针会继续遍历，直到找到一个和当前慢指针不同的数时，让慢指针右移一位，将值覆盖。

文字表达可能会不太清楚，按照代码逻辑在纸上画一下就能理解整个过程了。

public class question26 {
    public int removeDuplicates(int[] nums) {
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0;fastIndex < nums.length;fastIndex++){
            if (nums[fastIndex] != nums[slowIndex]) {
                slowIndex++;
                nums[slowIndex] = nums[fastIndex];
            }
        }
        return slowIndex + 1;
    }
}

 让我们接着看第283题：

给定一个数组 nums,编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。
请注意,必须在不复制数组的情况下原地对数组进行操作。

同样地，我们可以采用快慢指针进行操作，当快指针遍历到0的时候，将此位置的0和前一个位置的nums[slowIndex]调换位置， 实现将0进行后移一位的操作，最终就可以把所有的0移动到数组的最后。由于数组内元素没法直接交换，我们采用temp临时变量进行存储。

public class question283 {
    public void moveZeroes(int[] nums) {
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0;fastIndex < nums.length;fastIndex++) {
            if (nums[fastIndex] != 0) {
                int temp = nums[fastIndex];
                nums[fastIndex] = nums[slowIndex];
                nums[slowIndex] = temp;
                slowIndex++;
            }
        }

    }
}

就还剩两题了，加油，奥利给！！！！！！！！！

第844题：

给定s和t两个字符串,当它们分别被输入到空白的文本编辑器后,
如果两者相等,返回true。#代表退格字符。
注意：如果对空文本输入退格字符，文本继续为空。

题目把‘#’规定成退格键，即‘a#b#’=‘’，‘ab#c’=‘ac’

首先我们要注意的是，题目给定的是string字符串，我们写一个方法，将其处理成数组，再将数组返回成需要的字符串。

想象一下，如果fastIndex遍历到#，就意味着需要删除#之前的一个元素，那我们如何使用覆盖来达到删除的目的呢？此时只需要让slowIndex左移一位，利用fastIndex把#的后一位覆盖到nums[slowIndex]这里。

按照上面的逻辑，我们在演草纸上简单画一下：“a#b”会变成“b#b”

可是这和我们的答案“b”，还是有一定的差距，又如何处理这个问题呢？

我们知道，String中有一个valueof方法，可以指定数组转到字符串的起始位置和长度，我们只需要把长度设定到slowIndex对应的索引值即可。上代码：

public class question844 {
    public boolean backspaceCompare(String s, String t) {
        return changeString(s).equals(changeString(t));
    }

    public String changeString(String str){
        int fastIndex = 0;
        int slowIndex;
        //将string转换为数组
        char[] chars = str.toCharArray();
        for (slowIndex = 0;fastIndex < chars.length;fastIndex++) {
            if (chars[fastIndex] != '#') {
                chars[slowIndex] = chars[fastIndex];
                slowIndex++;
            } else if (chars[fastIndex] == '#' && slowIndex != 0) {
                slowIndex--;
            }
        }
        //重新将数组拼接成string
        return String.valueOf(chars,0,slowIndex);
    }
}

嗨嗨害，最后一题！

第977题：

给你一个按非递减顺序排序的整数数组nums，
返回每个数字的平方组成的新数组,要求也按非递减顺序排序

 题目很好理解，也没有什么需要多解释的。先送给大家一个极为简单的方法：

public class question977 {
    public int[] sortedSquares(int[] nums) {
        int[] ans = new int[nums.length];
        for (int i = 0; i < nums.length; ++i) {
            ans[i] = nums[i] * nums[i];
        }
        Arrays.sort(ans);
        return ans;
    }
}

顺畅且丝滑（当然是我看了答案），但是为了满足我们的标题，只好将其用快慢指针再次实现一遍：

public class question977 {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int index = nums.length - 1;
        int[] ans = new int[nums.length];
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                ans[index] = nums[left] * nums[left];
                index--;
                left++;
            } else  {
                ans[index] = nums[right] * nums[right];
                index--;
                right--;
            }
        }
        return ans;
    }
}

 由于考虑到一个数的平方为非负，所以负数的平方可能会大于正数的平方，所以平方后的最大值只可能在数组的两端出现(非递减顺序排列)，所以我们让左指针从左往右遍历，右指针从右往左遍历，平方后相比，谁牛b谁放到ans数字的末尾，就这样实现了非递减排列。