20220225

对撞指针：指的是两个指针 left、right 分别指向序列第一个元素和最后一个元素，然后 left 指针不断递增，right 不断递减，直到两个指针的值相撞（即 left == right），或者满足其他要求的特殊条件为止。

步骤:
(1) 两个指针 left，right, left指向第一个元素. right指向最后一个元素;
(2)相互靠近: left += 1, right -= 1
(3)相撞: left == right 或其他条件跳出条件

一般用来解决有序数组或者字符串问题

快慢指针：指的是两个指针从同一侧开始遍历序列，且移动的步长一个快一个慢。移动快的指针被称为 「快指针（fast）」，移动慢的指针被称为「慢指针（slow）」。两个指针以不同速度、不同策略移动，直到快指针移动到数组尾端，或者两指针相交，或者满足其他特殊条件时为止。

步骤
(1) 两个指针 slow、fast, 一般slow = 0, fast = 1
(2)两个指针分别满足条件移动
(3)快指针到头或其他条件跳出

一般用于处理数组中的移动、删除元素问题，或者链表中的判断是否有环、长度问题

分离双指针：两个指针分别属于不同的数组 / 链表，两个指针分别在两个数组 / 链表中移动。

步骤
(1)两个指针 left_1、left_2, 分别指向两个数组, 链表的首个元素
(2)满足条件left_1、left_2同时右移, 或只移动其中一个
(3)其中一个数组或链表遍历完 或者 其他条件满足跳出

一般用于处理有序数组合并，求交集、并集问题

思路: 利用fast, slow两个相差n的指针遍历一遍链表求解.

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0, head)
        fast, slow = head, dummy

        while n:            # 令fast 和 slow 中间相差n个节点
            fast = fast.next
            n -= 1
        while fast:    
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy.next

思路: 建立cur, pre -> None解决

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

思路: 建立快慢双指针slow, fast解决问题 >>> fast负责遍历l链表, slow负责记录不重复元素

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if not head or not head.next:return head
        slow, fast = head, head
        while fast:
            if fast.val != slow.val:
                slow = slow.next
                slow.val = fast.val
            fast = fast.next
        slow.next = None
        return head

思路: 利用归并排序 >>> 快排和插排会超时 >>> 归并分为分割和合并两步骤 >>> 其中分割即设计快慢指针分为两个链表 >>> 合并即合并两个有序链表同上题思路

class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:return head 
        #分割
        slow, fast = head, head.next
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        left_head, right_head = head, slow.next
        slow.next = None  # 实现分割


        #合并
        def merge(left, right):
            if not left:return right
            if not right:return left
            if left.val <= right.val:
                left.next = merge(left.next, right)
                return left
            else:
                right.next = merge(left, right.next)
                return right
        
        #递归排序
        return merge(self.sortList(left_head), self.sortList(right_head))

思路: 双指针, 长短互补 >>> 利用p1, p2指向两个链表头 >>> 在未找到相同节点前提下, 若其中一节点到达None, 指向另一链表表头 >>> 弥补长度差距, 迟早相交 >>> 若无相同节点, 也会在同时指向None时停下

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        p1, p2 = headA, headB
        while p1 != p2:
            p1 = p1.next if p1 else headB
            p2 = p2.next if p2 else headA
        return p1