Seven double pointers

1.1 Foundation

Collision pointer: refers to two pointers, left and right, pointing to the first element and the last element of the sequence respectively, and then the left pointer increases and the right decreases until the values of the two pointers Collide (i.e. left == right), or meet other special conditions.

Steps:
(1) The two pointers left, right and left point to the first element Right points to the last element;
(2) Close to each other: left += 1, right -= 1
(3) Collision: left == right or other conditions jump out of the condition

It is generally used to solve the problem of ordered array or string

Speed pointer: refers to that two pointers start to traverse the sequence from the same side, and the moving step is fast and slow. A pointer that moves fast is called a fast pointer, and a pointer that moves slowly is called a slow pointer. The two pointers move at different speeds and strategies until the fast pointer moves to the end of the array, or the two pointers intersect, or other special conditions are met.

• step
  (1) Two pointers: slow and fast. Generally, slow = 0 and fast = 1
  (2) The two pointers meet the conditions to move respectively
  (3) Fast pointer to the end or other conditions jump out

It is generally used to deal with the problem of moving and deleting elements in the array, or to judge whether there are rings and length problems in the linked list

Separate double pointers: the two pointers belong to different arrays / linked lists, and the two pointers move in the two arrays / linked lists respectively.

• step
  (1) Two pointers left_1,left_2. Point to two arrays respectively, the first element of the linked list
  (2) Satisfy condition left_1,left_2 move right at the same time, or move only one of them
  (3) When one of the arrays or linked lists is traversed or other conditions are met, it will jump out

It is generally used to deal with the problems of ordered array merging, intersection and union

1.2 title

1.2.1 19 . Delete the penultimate node of the linked list

• Idea: use the two pointers of fast and slow with a difference of n to traverse the linked list for solution

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

        while n:            # Make the difference between fast and slow n nodes
            fast = fast.next
            n -= 1
        while fast:    
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy.next

1.2.2 206 . Reverse linked list

• Idea: establish cur, pre - > none solution

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

1.2.3 83 . Delete duplicate elements in the sorting linked list

• Idea: establish a fast and slow double pointer slow, fast to solve the problem > > > fast is responsible for traversing the l linked list, and slow is responsible for recording non repeating elements

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

1.2.4 148 . Sort linked list

• Idea: using merge sort > > > fast row and insertion will timeout > > > merge is divided into two steps: segmentation and merging > > > where segmentation is to design the speed pointer into two linked lists > > > merging is to merge two ordered linked lists. The same idea as above

class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:return head 
        #division
        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  # Realize segmentation


        #merge
        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
        
        #Recursive sorting
        return merge(self.sortList(left_head), self.sortList(right_head))

1.2.5 160 . Intersecting linked list

• Idea: double pointer, complementary length > > > use P1 and P2 to point to two chain headers > > > on the premise of not finding the same node, if one node reaches None, point to the other chain header > > > make up the length gap and intersect sooner or later > > > if there is no same node, it will also stop when pointing to None at the same time

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