双指针简单记录

算法解释： 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。也可以延伸到多个数组的多个指针。 若两个指针指向同一数组，遍历方向相同且不会相交，则也称为滑动窗口（两个指针包围的区域即为当前的窗口），经常用于区间搜索。 若两个指针指向同一数组，但是遍历方向相反，则可以用来进行搜索，待搜索的数组往往是排好序的。

167. Two Sum II - Input array is sorted (Easy)

题目描述：

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。

函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

示例：

输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 

代码：

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        n = len(numbers)
        l, r = 0, n-1
        for i in range(n):
            if numbers[l] + numbers[r] > target:
                r -= 1
            if numbers[l] + numbers[r] < target:
                l += 1
            
        return ([l+1,r+1])
            

88.Merge Sorted Array(Easy)

题目描述：

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。

示例：
输入：
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

输出：[1,2,2,3,5,6]

一句话思路：

设置两个指针，指向两个数组的末尾m-1,n-1,然后另设一个指针指向第一个数组的m+n-1位，每次比较将较大的元素放在第三个指针指向的位置，每次向前移动前两个指针，第三个指针也要向前移动一位。
如果nums1的元素已经比较完，记得把nums2的剩余元素复制到nums1的剩余位置。

代码：

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        p1 = m-1
        p2 = n-1
        p = m + n - 1
        while p1 >= 0 and p2 >= 0:
            if nums1[p1] < nums2[p2]:
                nums1[p] = nums2[p2]
                p2 -= 1
            else:
                nums1[p] = nums1[p1]
                p1 -= 1
            p -= 1
        nums1[:p2+1] = nums2[:p2+1]

142. Linked List Cycle II (Medium)

题目描述：

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

示例：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

一句话思路：

设置快慢指针slow 和 fast，起始位置在head。
每次 fast 前进两步，slow 前进一步。
当 slow 和 fast 第一次相遇时，我们将fast 重新移动到链表开头head处，并让 slow 和 fast 每次都前进一步。
当 slow 和 fast 第二次相遇时，相遇的节点即为环路的开始点。

代码：

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return

        slow, fast = head, head

        while True:
            if not fast or not fast.next:
                return
            fast, slow= fast.next.next, slow.next
            if fast == slow:
                break

        fast = head

        while slow != fast:
            slow = slow.next
            fast = fast.next

        return fast

练习题目：

633. Sum of Square Numbers (Easy) （Two Sum 题目的变形题之一）

题目描述：

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c 。

输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5

一句话思路：

双指针的题目首先需要两个双指针的位置。很容易想到平方根向下取整，得到的数值是右指针的位置，
左指针从零开始，然后比较平方和与目标数c的大小，移动左右指针。

注意单独判断c==0的情况。

代码：

class Solution:
    def judgeSquareSum(self, c: int) -> bool:
        if c == 0:return True
        s = int(pow(c,0.5))
        a, b = 0, s
        while a < b:
            if a**2 + b**2 > c:
                b -= 1
            if a**2 + b**2 < c:
                a += 1
            if a**2 + b**2 == c:
                return True
        return False

680. Valid Palindrome II (Easy)（Two Sum 题目的变形题之二）

题目描述：

给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。
示例：

输入: "abca"
输出: True
解释: 你可以删除c字符。

一句话思路：

初始化两个指针l,r分别指向字符串的第一个字符和最后一个字符。
每次判断两个指针指向的字符是否相同，如果相同，令 l = l + 1 和 r = r - 1，然后判断更新后的指针范围内的子串是否是回文字符串。
如果两个指针指向的字符不同，则两个字符中必须有一个被删除，此时分成两种情况：
即删除左指针对应的字符s[l]，留下子串 s[l - 1], s[l + 1], ..., s[r]，
或者删除右指针对应的字符s[r]，留下子串 s[l], s[l + 1], ..., s[r - 1]。
当这两个子串中至少有一个是回文串时，就返回True。

代码：

class Solution:
    def validPalindrome(self, s: str) -> bool:
        def checkPalindrome(l, r):
            i,j = l, r
            while i < j:
                if s[i] != s[j]:
                    return False
                i += 1
                j -= 1
            return True

        n = len(s)
        l, r = 0, n-1
        while l < r:
            if s[l] == s[r]:
                l += 1
                r -= 1
            else:
                return checkPalindrome(l+1,r) or checkPalindrome(l,r-1)
        return True