《算法通关村第三关——双指针的妙用》

白银挑战——双指针思想及应用

原地移除所有数值为 val 的元素

链接：27. 移除元素

快慢双指针

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

对撞双指针

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

删除有序数组的重复项

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

public int removeDuplicates(int[] nums) {
    int slow = 1;
    for(int fast = 0; fast < nums.length; fast++) {
        // 表示和前一个元素不同，在同一个数组进行操作
        if(nums[fast] != nums[slow - 1]) {
            nums[slow] = nums[fast];
        }
    }
}

其中，快指针表示的是遍历了整个数组，而慢指针则是在原来的基础上创建了一个新的数组。

数组翻转

链接：189. 轮转数组

    public void rotate(int[] nums, int k) {
        k %= nums.length;
        // 先全部翻转
        reverse(nums, 0, nums.length - 1);
        // 按k分成两部分进行翻转
        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;
        }
    }

区间汇总问题

链接：228. 汇总区间

    public List<String> summaryRanges(int[] nums) {
        List<String> ans = new ArrayList<>();
        int n = nums.length;
        int slow = 0;
        for(int fast = 0; fast < n; fast++) {
            // 快慢指针不符合条件的时候
            if(fast - slow != nums[fast] - nums[slow]) {
                if(fast - slow == 1) {
                    // 只有一个值
                    ans.add(String.valueOf(nums[slow]));
                } else {
                    // 连续的
                    ans.add(nums[slow] + "->" + nums[fast - 1]);
                }
                slow = fast;
            }
            // 最后一个数字需要处理
            if(fast == n - 1) {
                if(fast == slow) {
                    ans.add(String.valueOf(nums[slow]));
                } else {
                    ans.add(nums[slow] + "->" + nums[fast]);
                }
            }
        }
        return ans;
    }