1. 双指针思想

双指针不仅指两个指针，也可以是两个变量，指向两个值。

有三种类型：

• 快慢型：一前一后
• 对撞型：从两端向中间靠拢
• 背向型：从中间向两端分开

2. 删除元素专题

2.1原地移除元素

(1)快慢指针

思路：每次找到等于val就移动数组当val值比较多的时候时间复杂度太高，使用fast指针扫描等于val的值连续删除，当找到一段连续val中第一个不等于val的值的时候就覆盖实现批量删除。

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow = 0;
        int fast = 0;
        int len = nums.length;
        while(fast < nums.length){
            if(nums[fast] == val){
                fast++;
                len--;
            }else{
                nums[slow++] = nums[fast++];
            }
        }
        return len;
    }
}

 （2）对撞指针

思路：两个指针一左一右，题目没有规定元素顺序，故当左指针指向要删除的值的时候就将右指针的值替换上来，右指针左移一位，实现删除一位的效果。

class Solution {
    public int removeElement(int[] nums, int val) {
        int right = nums.length - 1;
        int left = 0;
        int len = nums.length;
        while(left <= right){
            if(nums[left] != val){
                left++;
            }else{
                nums[left] = nums[right--];
                len--;
            }
        }
        return len;
    }
}

2. 2删除有序数组中的重复项

 思路：双指针，当一直重复fast指针就一直往后扫，直到扫到不重复的值，然后将不重复的值覆盖slow指向的重复的值，注意slow初始化为1，这样第一次进循环一定相等。

两个关键点：slow保留指针什么时候移动、fast指向怎么算符合条件的值

此处slow指针当元素开始不重复，即fast指向新值的时候移动

nums[fast] != nums[fast- 1]代表指向新值

class Solution {
    public int removeDuplicates(int[] nums) {
        int slow = 1;
        int fast = 1;
        while(fast < nums.length){
            if(nums[fast] != nums[fast- 1]){
                nums[slow++] = nums[fast];
            }
            fast++;
           
        }
        return slow;
    }
}

当删除使元素出现k个重复：

前k个不需要管，slow表示需要保留的值

当且仅当 nums[slow−k]=nums[fast]时，当前待检查元素 nums[fast]不应该被保留

（因为此时必然有 nums[slow−k]=nums[slow−(k-1)]=...=nums[fast]）

例如：int[] arr = new int[]{1,1,1,2, 2,3,4,5,5,6,7,8,8,8,8,9};

此处slow指针当重复的元素不超过k个时移动

nums[fast] != nums[slow - k]代表fast指向的值在重复的k个元素范围之内

public static int removeDuplicatesk(int[] nums,int k) {
        int slow = k;
        int fast = k;
        while(fast < nums.length){
            if(nums[fast] != nums[slow - k]){
                nums[slow] = nums[fast];
                slow++;
            }
            fast++;
        }
        return slow;
    }

扩展：出现重复的元素都不要

此处slow指针当前后元素都只出现一次时移动

nums[fast] == nums[fast -1]判断元素是否重复了

public static int removeDuplicates0(int[] nums,int k) {
        int slow = 0;
        int fast = 1;
        int count = 0;//用来判断元素是否出现重复
        while(fast < nums.length){
            if (nums[fast] == nums[fast -1]){
                count++;
            } else if(nums[fast] != nums[fast -1]&&count!=0){
                //当元素出现不重复并且fast指向的是新值
                nums[slow] = nums[fast];
                //开始新的值重置
                count = 0;
            } else if (nums[fast] != nums[fast -1]&&count == 0){
                //当元素不重复，并且fast指向前也是不重复的值
                //这时slow保留指针才移动
                nums[++slow] = nums[fast];
            }
            fast++;
        }
        return count == 0 ? slow+1 : slow;
    }

3.元素奇偶移动

思路：对撞型双指针，当left指到奇数，right指到偶数就相互交换。需要注意一些边界处理细节，避免数组越界情况。

class Solution {
    public int[] sortArrayByParity(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while(left<right){
            while(left<right && nums[left] % 2 == 0){
                left++;
            }
            while(left<right && nums[right] % 2 != 0){
                right--;
            }
            if(left<right){
                int t = nums[left];
                nums[left] = nums[right];
                nums[right] = t;
                left++;
                right--;
            }
            
        }
        return nums;
    }
}

4.数组轮转

思路：

方法一、暴力解法，找到开始轮转的数，然后剪切拼接到新的数组。需要注意k可能比数组长度大得取模

class Solution {
    public void rotate(int[] nums, int k) {
        int[] res = new int[nums.length];
        int left = 0;
        int right = nums.length;
        int kk = k;
        while( k % nums.length>0){
            right--;
            k--;
        }
        int i = 0;
        for(;i<kk%nums.length;i++){
            res[i] = nums[right%nums.length];
            right++;
        }
        for(;i<nums.length;i++){
            res[i] = nums[left++];
        }
        System.arraycopy(res, 0, nums, 0, nums.length);
    }
}

 优化：i+k将当前元素往右移动k，取模避免数组越界

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] newArr = new int[n];
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        System.arraycopy(newArr, 0, nums, 0, n);
    }
}

方法二、翻转，往右轮转结果就是数组后面的值移动到了前面，进行一次整体翻转，再在k处分成左右两部分再次翻转就是往右轮转的最终效果了。

class Solution {
    public void rotate(int[] nums, int k) {
        revers(nums,0,nums.length-1);
        revers(nums,0,(k%nums.length)-1);
        revers(nums,(k%nums.length),nums.length-1);
    }

    public void revers(int[] nums,int l,int r){
        while(l<r){
            int t = nums[l];
            nums[l] = nums[r];
            nums[r] = t;
            l++;
            r--;
        }
    }
}

5.数组的区间

 思路：题目的意思是说不连续递增的就断开输出

双指针，slow指向区间起始，fast负责寻找到区间结束

class Solution {
    public List<String> summaryRanges(int[] nums) {
        List<String> res = new ArrayList<>();
        int slow = 0;
        int fast = 0;
        while(fast<nums.length){
            if(fast + 1 == nums.length || nums[fast] + 1 != nums[fast+1]){
                if(slow == fast){
                    res.add("" + nums[slow]);
                }else{
                    res.add(nums[slow] + "->" + nums[fast]);
                }
                slow = fast+1;
            }
            fast++;
        }
        return res;
    }
}