算法通关村——第二关双指针妙用

双指针

27.移除元素

快慢指针

这里摒弃了删除一个元素，就将后面所有元素前移的方法

left指向的位置是可能会填入值的位置的前一个位置

right指向是位置是待判断的值：如果值不等于val，则需要填入（left需要自加），否则继续后移

public int removeElement(int[] nums, int val) {
    int len = nums.length;
    //双指指针
    int left = -1, right = 0;

    while(right != nums.length) {
        if(nums[right] == val) {
        	len--;
        } else {
            left++;
            nums[left] = nums[right];
        }
        right++;
    }
    return len;
}

答案写法

public static int removeElement(int[] nums, int val) {
    int slow = 0;
    int len = nums.length;
    //fast为快指针
    //和我代码中的right是一样的作用
    for(int fast = 0; fast < nums.length; fast++) {
        if(nums[fast] != val) {
            //将fast指向的非val值填入slow位置
            nums[slow] = nums[fast];
            slow++;
        } else {
            //找到与val相等的值，说明要少一个元素了
            len--;
        }
    }
    return len;
}

对撞指针

也叫交换移除，核心思想是从右侧找到不是val的值来顶替左侧是val的值。

盗图如下：

我自己写了一版，没法处理只有一个元素的情况

结果，答案也无法处理一个元素的情况。

我没想清楚怎么处理

public int removeElement(int[] nums, int val) {
    int len = nums.length;
    //双指指针
    int left = 0, right = len - 1;
	
    for(left = 0; left <= right;) {
        if((nums[left] == val) && (nums[right] != val)) {
            nums[left] = nums[right];
            len--;
        }
        if(nums[left] != val) left++; 
        if(nums[right] == val) right--; len--;
    }
    return len;
}

public int removeElement(int[] nums, int val) {
    int len = nums.length;
    int left = 0, right = len - 1;

    while (left <= right) {
        if (nums[left] == val) {
            //出现left和right指向的都是val值的情况
            //调整right，直到出现(nums[left] == val) && (nums[right] != val)为真
            //注释：如果是只有一个元素，且为val时，
            //会出现left>right的情况，在下面while循环外被break
            while (left <= right && nums[right] == val) {
                right--;
                len--;
            }
            if (left > right) {
                break; // 处理完所有与 val 相等的元素
            }
            nums[left] = nums[right];
            right--;
            len--;
        }
        left++;
    }

    return len;
}

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

和移除元素很相似，但是这一题聚焦于重复项

由于给的数组非严格递增，说明，重复项大概率出现在一块区域。

所以，第一个反应，两个指针，left、right，从0一起开始，right先移动

第一种情况，nums[left]==nums[right]，出现重复项区域，进行处理。会使用之前的方法，用重复区外的nums[right]去填充nums[left]。

但是会出现，重复区外的元素不够填充(这种情况也不需要考虑，题目只关心有几个不重复元素)

第二种情况，nums[left] != nums[right]，指针同时后移

public int removeDuplicates(int[] nums) {
    int len = nums.length;
    if(len <= 1) return len;
    int left = 0, right = 0;

    while(right < nums.length - 1) {
        right++;
        if(nums[left] == nums[right]) {//出现重复项
            len--;
            continue;
        } else {//right指向重复区域外，开始填充重复区域
            //特殊情况：right超限(排除，超限没法进入while)
            //重复区域也要留一个元素
            nums[++left] = nums[right];
        }
    }
    return len;
}

905.按奇偶排序数组

这里属于对撞指针的一个例子

public int[] sortArrayByParity(int[] nums) {
    if(nums.length <= 1) return nums;
    int len = nums.length;
    int left = -1, right = len;
    //先从左遍历找奇数，找到奇数后，从右遍历找偶数，交换
    //注意此处的边界问题：都是偶数的情况，可以考虑一下
    while(left < right - 1) {
        left++;
        //左侧出现奇数
        if(nums[left] % 2 != 0) {
            //从右遍历找偶数
            while(left < right) {
                right--;
                if(nums[right] % 2 == 0) {
                    int temp = nums[left];
                    nums[left] = nums[right];
                    nums[right] = temp;
                    break;
                }
            }
        }
    }
    return nums;
}

189.轮转数组

按照最常规的方式，做平移，效率非常低。

public void rotate(int[] nums, int k) {
    if(nums.length <= 1) return;
    int size = nums.length;
    //有可能k大于size
    k = k % size;
    //用于存储最后面的k个元素，最后填充到数组前
    int[] temp = new int[k];

    //temp[]存储最后面的k个元素
    int j = 0;
    for(int i = size - k; i < size; i++) {
        temp[j++] = nums[i];
    }
    //倒数第k-1个元素移动到倒数第1个元素位置
    //即为下标为i的元素移动到i+k
    for(int i = size - k - 1; i >= 0; i--) {
        nums[i + k] = nums[i];
    }
    //将末尾元素填入开头位置
    for(int i = 0; i < k; i++) {
        nums[i] = temp[i];
    }
}

第二种方法，通过数组的三次反转

通过对第一种方法的思考，得到一个结论，倒数k个元素是要到开头位置的。

通过数组的一次整体反转，倒数k个元素的反转，会到开头位置，前面的所有元素会到后面。

第二次反转，对前面k个元素做反转，再对后面的数组做反转

举例，[1,2,3,4,5,6]作为输入，3作为k

第一次反转，[6,5,4,3,2,1]

第二次反转，[4,5,6,3,2,1]

第三次反转，[4,5,6,1,2,3]。成功得到效果。

public void rotate(int[] nums, int k) {
    if(nums.length <= 1) return;
    k = k % nums.length;
    reverse(nums, 0, nums.length - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, nums.length - 1);
}
//nums为待反转的数组，left,right为待反转的左右界限
public void reverse(int[] nums, int left, int right) {
    while(left < right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
        left++; right--;
    }
}

228.汇总区间

两个指针left和right，left确定区间开头，right确定区间结尾（通过判断nums[right+1]是否连续，来确定是否自加）。

确定一个区间后，left = right+1; right = left；

转字符串的方法，使用StringBuilder会更好

public List<String> summaryRanges(int[] nums) {
    List<String> ans = new ArrayList<String>();
    int left = 0, right = 0;
    //用于存放right - 1访问的元素，
    //用于判断下一个元素是否连续
    int temp;
    //循环都需要仔细思考边界问题
    while(right < nums.length) {
        temp = nums[right];
        right++;
        if(right != nums.length && nums[right] == temp + 1) {//连续的情况
            continue;
        } else {//不连续的情况，要更新list
            //这里也要区分两种情况
            //1.区间内有多个数字
            //2.区间内只有一个数字
            if(nums[left] != temp) {
                ans.add(nums[left] + "->" + temp);
            } else {
                ans.add(nums[left]+"");
            }
            left = right;
        }
    }
    return ans;
}

163.缺失区间

方法比较笨，但是复杂度也完全ok

public List<List<Integer>> findMissingRanges(int[] nums, int lower, int upper) {
    List<List<Integer>> result = new ArrayList<>();

    // 处理边界情况
    if (nums == null || nums.length == 0) {
        List<Integer> range = new ArrayList<>();
        range.add(lower);
        range.add(upper);
        result.add(range);
        return result;
    }

    // 处理第一个区间
    if (lower < nums[0]) {
        List<Integer> range = new ArrayList<>();
        range.add(lower);
        range.add(nums[0] - 1);
        result.add(range);
    }

    // 处理中间区间
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] > nums[i - 1] + 1) {
            List<Integer> range = new ArrayList<>();
            range.add(nums[i - 1] + 1);
            range.add(nums[i] - 1);
            result.add(range);
        }
    }

    // 处理最后一个区间
    if (upper > nums[nums.length - 1]) {
        List<Integer> range = new ArrayList<>();
        range.add(nums[nums.length - 1] + 1);
        range.add(upper);
        result.add(range);
    }

    return result;
}