LeetCode算法—双指针

一：普通双指针

1、题目1：两数求和-1

（1）方法1：普通双指针

思路：定义两个指针；第一个指针放在数组的首位；第二个指针放在下一个元素的位置；然后遍历这个；如果两个元素的和为目标值就返回对对应的下标和索引值！

Copy
def fuc(nums,target):
    for i in range(len(nums)):
        for j in range(i+1,len(nums)):
            if nums[i]+nums[j]==target:
                retrun [i,j]
     return ""

（2）方法2：对撞双指针

思路：让第一个指针指向第一个元素；第二个指针指向第二个元素；然后将数组排列为有序数组；核心：如何和小于目标值的话说明最小的值太小了；第一个指针需要左移；如果和大于目标值的话说明最大的值太大了；第二个指针需要右移；符合条件使用index方法发返回未排序之前元素对应的下标索引！

Copy
def func(nums,target):
    i,j=0,len(nums)-1#让i指向第一个元素；j指向最后一个元素
    sorted_nums=sorted(nums)#将数组排列为有序的
    while i<j:
        sum=sorted_nums[i]+sorted_nums[j]

        if sum>target:
            j-=1
        elif sum<target:
            i+=1
        else:#返回未排序之前对应的下标索引；使用.index方法实现
            index1=nums.index(sorted_nums[i])
            index2=nums.index(sorted_nums[j])
            return [index1,index2]

题目2：移除元素-27

（1）思路：定义两个指针i，j:i指针用于存放与目标值不相等的元素；j指针用于遍历数组

Copy
class Solution:
    def removeElement(self, nums, val: int) -> int:
        low,fast=0,0
        while fast<len(nums):
            if nums[fast]!=val:
                nums[low]=nums[fast]#将元素移到数组首部
                low+=1#移动到数组下一个位置
            fast+=1#继续遍历数组
        return low

二：对撞双指针

题目1：反转字符串-344
（1）思路：定义两个指针left,right；然后交换元素完成题目要求；也可以使用遍历反转；容器切片等操作进行反转

Copy
def func(s):
    left=0
    right=len(s)-1
    while left<right:
        s[left],s[right]=s[right],s[left]#核心语句
        #如果直接是s[left]=s[right]的话，s[left]的值就丢失了
        #无法达到反转字符的效果
        left+=1
        right-=1
    retrun s

题目2 三数求和-15

（1）思路：定义两个指针；首先对数组进行排序；然后初始化左指针和右指针；左指针指向数组的第二个元素；右指针指向数组左右一个元素；判断的过程就是先遍历数组；取出第一个元素；然后通过双指针找其他两个数与第一个数加起来等于目标值的元素！如果有的话就返回这个三个数；同时也要判断元组不能重复！

Copy
class Solution:
    def threeSum(self, nums):
        nums.sort()  # 首先对数组进行排序
        result = []  # 用于存储满足条件的三元组
        for i in range(len(nums)):
            left = i + 1  # 初始化左指针，指向当前元素的下一个位置
            right = len(nums) - 1  # 初始化右指针，指向数组的末尾
            if nums[i] > 0:  # 如果当前元素大于0，则后续三数之和必然大于0，直接结束循环
                break
            if i >= 1 and nums[i] == nums[i - 1]:  # 跳过重复元素，避免重复的三元组
                continue
            while left < right:
                target = nums[i] + nums[left] + nums[right]  # 计算三数之和
                if target < 0:  # 如果和小于0，左指针右移以增大总和
                    left += 1
                elif target > 0:  # 如果和大于0，右指针左移以减小总和
                    right -= 1
                else:  # 找到满足条件的三元组
                    result.append([nums[i], nums[left], nums[right]])
                    # 跳过重复的左指针元素
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1
                    # 跳过重复的右指针元素
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1
                    # 移动指针继续寻找其他可能的三元组
                    left += 1
                    right -= 1
        return result  # 返回最终的结果列表

题目3 救生艇-881

（1）思路：双指针问题；就是简单的过船问题：两个人的体重和小于目标值的时候；可以过河；如果两个人的体重和大于目标值；说明体重大的那个人需要一个人坐一个船；直接对撞双指针拿下！

Copy
class Solution:
    def numRescueBoats(self, people,limit) -> int:
        people.sort()
        left, right = 0, len(people) - 1
        count = 0

        while left <= right:
            if people[left] + people[right] <= limit:
                left += 1#就是两个人同时上传；移动指针判断下一组元素
                right -= 1
            else:
                right -= 1#体重大的人一个人上船
            count += 1
        return count

三：快慢双指针

题目1：环形链表-141

（1）思路：经典的龟兔赛跑算法；也成为快慢双指针；定义一个慢指针和一个快指针；如果链表是环形的话；那么快指针和慢指针会相遇；如果不相遇说明就不是环形链表:慢指针每次向前移动一位；快指针每次向前移动两位；如果链表有环的话纳闷slow和fast始终会相遇的

Copy
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

def hasCycle(head):
    if not head or not head.next:
        return False
    slow = head#慢指针指向头节点
    fast = head.next#快指针指向第二个节点
    while slow != fast:
        if not fast or not fast.next:
            return False
        slow = slow.next#向前移动一步
        fast = fast.next.next#向前移动两部

    return True