Datawhale Task4-查找2（对撞指针）_链表对撞指针-CSDN博客

本文链接：https://blog.csdn.net/m0_37166734/article/details/108287897

对撞指针

1.前言

本次查找2的主题是对撞指针，即双指针。以LeetCode的1.两数之和和15.三数之和为例。

2.例子

2.1 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思路1：用两层循环的暴力法可以做，但时间复杂度为o(n^2)，是不是可以优化呢。
暴力法的代码（Java）

public int[] twoSum(int[] nums, int target) {
        int[] a = new int[2];
        int i=0,j=0;//定义两个指针
        for(i=0;i<nums.length-1;i++){//控制头指针
            for(j=i+1;j<nums.length;j++){//控制尾指针，不断在头指针后面的元素移动
                if(nums[i]+nums[j]==target){//符合条件
                //构建返回结果并返回
                    a[0]=i;
                    a[1]=j;
                    return a;
                }
            }
        }
        return null;//未找到a+b=target,返回空
    }

在这里插入图片描述

思路2：使用对撞指针，先让数组有序，然后头指针初始化在数组的开头，尾指针初始化为数组的末尾，通过与target的对比，不断调节头指针或尾指针的位置知道找到合适的两个下标。由于使数组有序让元素位置发生了改变，根据元素在原数组的位置返回下标。
对撞指针的代码（Python）

class Solution:
    def twoSum(self, nums, target):
        temp = nums.copy()# 浅复制，temp的改变不会改变nums
        temp.sort()# 升序排序
        i = 0
        j = len(nums) - 1
        while i < j:
            if (temp[i] + temp[j]) > target:
                j = j - 1
            elif (temp[i] + temp[j]) < target:
                i = i + 1
            else: # 符合条件
                break
        p = nums.index(temp[i])  # 获得第一次出现temp[i]的下标
        nums.pop(p)  # 弹出，为了避免temp[i] = temp[j]时总是返回同一个下标
        k = nums.index(temp[j])
        if k >= p:  # pop导致下标-1，为了找到在以前的位置，故+1
            k = k + 1
        return [p, k]

在这里插入图片描述

思路3：使用哈希表hashMap(数组与链表的组合，十分适合查找，储存的数据量没有限制)。

遍历元素时，访问到的元素固定为加法的前一项，通过hashMap找寻加法的第二项，hashMap存储着以前遍历过的元素。
代码如下：

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        hashmap = {}
        for index, num in enumerate(nums):# 迭代nums，返回下标和元素值
            another_num = target - num #计算还想要多少
            if another_num in hashmap:#找到想要的元素，返回结果
                return [hashmap[another_num], index]
            hashmap[num] = index#否则将访问的元素加入哈希表，方便下一次使用
        return None#找不到a+b=target，返回None

在这里插入图片描述
第三种思路效率更高，利用了合适的数据结构，但是第二种双指针的想法也很好。

2.2 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。
示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

思路1：三数之和是两数之和的升级版，是不是可以使用最外层循环控制c,然后用上题的思路二使得a+b=-c(-c是target)呢，但是会出现很多的重复三元组，这是题目所不允许的。
转载作者wu_yan_zu的思路，使用对撞指针也去重了。
思路2：特判，对于数组长度 n，如果数组为 null 或者数组长度小于 3，返回 []。
对数组进行排序。
遍历排序后数组：
若 nums[i]>0：因为已经排序好，所以后面不可能有三个数加和等于 0，直接返回结果。
对于重复元素：跳过，避免出现重复解
令左指针 L=i+1，右指针 R=n-1，当 L<R时，执行循环：
当 nums[i]+nums[L]+nums[R]==0，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将 L,R移到下一位置，寻找新的解
若和大于 0，说明 nums[R]太大，R 左移
若和小于 0，说明 nums[L]太小，L 右移

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        
        n=len(nums)
        res=[]
        if(not nums or n<3):
            return []
        nums.sort()
        res=[]
        for i in range(n):
            if(nums[i]>0):
                return res
            if(i>0 and nums[i]==nums[i-1]):
                continue
            L=i+1
            R=n-1
            while(L<R):
                if(nums[i]+nums[L]+nums[R]==0):
                    res.append([nums[i],nums[L],nums[R]])
                    while(L<R and nums[L]==nums[L+1]):
                        L=L+1
                    while(L<R and nums[R]==nums[R-1]):
                        R=R-1
                    L=L+1
                    R=R-1
                elif(nums[i]+nums[L]+nums[R]>0):
                    R=R-1
                else:
                    L=L+1
        return res