[力扣]双指针-CSDN博客

本文链接：https://blog.csdn.net/weixin_51699336/article/details/124251022

基本前面的文章都解过

代码随想录[原文指路]

移除元素[27]

快慢双指针

class Solution {
    public int removeElement(int[] nums, int val) {
        //快慢双指针
        int j=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=val){
                nums[j] = nums[i];
                j++;
            }
        }
        return j;
    }
}

首尾双指针

class Solution {
    public int removeElement(int[] nums, int val) {
        //首尾双指针(题目说了数组顺序可以改变)
        int left=0;
        int right=nums.length-1;
        while(left<=right){
            if(nums[left]==val){
                nums[left]=nums[right];
                right--;
            }else{
                left++;
            }
        }
        return left;
    }
}

比较含退格的字符串[844]

反转字符串[344]

字符串那篇使用如下方法

class Solution {
    public void reverseString(char[] s) {
        int len = s.length;
        char temp;//临时字符串
        for(int i=0;i<len/2;i++){
            temp = s[i];
            s[i]=s[len-i-1];
            s[len-i-1]=temp;
        }
    }
}

双指针

class Solution {
    public void reverseString(char[] s) {
        int left=0;
        int right=s.length-1;
        while(left<right){
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }
    }
}

替换空格[剑指 Offer 05]

统计空格字符个数，扩充空间到空白字符两倍
left与right分别指向原字符串尾部与扩充字符串尾部
个人认为直接调用 API(字符串那篇文章) 更为方便
此处不给出代码实现
双指针法指路

颠倒字符串中的单词[151]

去除多余空白字符
整体反转字符串
局部反转字符串
这样做不使用内置函数
个人认为直接调用 API(字符串那篇文章) 更为方便
此处不给出代码实现
双指针法指路

反转链表[206]

删除链表的倒数第 N 个结点[19]

链表相交[面试题 02.07]

环形链表 II[142]

三数之和[15]

思路指路,代码看随想录
三指针

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //三指针
        List<List<Integer>> ress = new ArrayList<>();
        //对数组排序
        Arrays.sort(nums);
        //nums[i] + nums[left] + nums[right] = 0
        for(int i=0;i<nums.length;i++) {
            //排序后第一个元素大于零，那么结果不可能为0
            if (nums[i] > 0) {
                return ress;
            }
            //注意比较[i+1]会漏 -->去重
            if (i>0 && nums[i]==nums[i-1]){
                continue;
            }
            int left =i+1;
            int right=nums.length-1;
            while(left<right){
                if(nums[i]+nums[left]+nums[right]>0){//结果>0，说明结果和要小一点，right--
                    right--;
                }else if(nums[i]+nums[left]+nums[right]<0){//结果<0，说明结果和要大一点，left++
                    left++;
                }else{
                    List<Integer> res = new ArrayList<Integer>();
                    res.add(nums[i]);
                    res.add(nums[left]);
                    res.add(nums[right]);
                    ress.add(res);
                    //找到结果，左右都去重，防止结果重复
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    //找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }
        }
        return ress;
    }
}

四数之和[18]

三数之和基础上再加一个指针k

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        //三数之和基础上再加一个指针k
        List<List<Integer>> ress = new ArrayList<>();
        Arrays.sort(nums);
        for(int k=0;k<nums.length;k++){
            //去重
            if(k>0 && nums[k]==nums[k-1]) continue;
            //nums[i] + nums[left] + nums[right] = target-nums[k]
            for(int i=k+1;i<nums.length;i++) {
                //注意比较[i+1]会漏 -->去重
                if (i>k+1 && nums[i]==nums[i-1]){
                    continue;
                }
                int left =i+1;
                int right=nums.length-1;
                while(left<right){
                    if(nums[i]+nums[left]+nums[right]>(target-nums[k])){
                        right--;
                    }else if(nums[i]+nums[left]+nums[right]<(target-nums[k])){
                        left++;
                    }else{
                        List<Integer> res = new ArrayList<Integer>();
                        res.add(nums[k]);
                        res.add(nums[i]);
                        res.add(nums[left]);
                        res.add(nums[right]);
                        ress.add(res);
                        //找到结果，左右都去重，防止结果重复
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;
                        //找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }
            }
        }
        return ress;
    }
}