刷题笔记——双指针

什么是双指针（对撞指针、快慢指针）

双指针，指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢指针）或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。

换言之，双指针法充分使用了数组有序这一特征，从而在某些情况下能够简化一些运算。

双指针在排序，合并，查找等问题中非常常见，一个嵌套的循环、常规的遍历、都可以通过双指针来解决问题。有效降低时间复杂度。

例子 Leetcode 88 合并有序数组

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        # for i in range(0, n):
        #     nums1[m+i] = nums2[i]
        # nums1.sort()
#双指针
        index1 = 0
        index2 = 0 
        temp = []
        while index1<m or index2<n:
            if index1 == m:
                temp.append(nums2[index2])
                index2 += 1
            elif index2 == n:
                temp.append(nums1[index1])
                index1 += 1
            elif nums1[index1]<nums2[index2]:
                temp.append(nums1[index1])
                index1 += 1
            else:
                temp.append(nums2[index2])
                index2 += 1
        nums1[:] = temp

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None


class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        #hash表
        # map = set()
        # temp = headA
        # while temp:
        #     map.add(temp)
        #     temp = temp.next
        
        # temp = headB
        # while temp:
        #     if temp in map:
        #         return temp
        #     else:
        #         temp = temp.next
        # return None
#双指针
#若有相交，两个指针走的距离会是相同的，一定能相遇
        p, q = headA, headB
        while p != q:
            if not p: p = headB
            else: p = p.next
            if not q: q = headA
            else: q = q.next
        return p

剑指offer 22

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
    #     p1 = self.reverse(head)
    #     test = p1
    #     n = 0
    #     while n+1 < k:
    #         test = test.next
    #         n += 1
    #     test.next = None
    #     p1 = self.reverse(p1)
    #     return p1
    # def reverse(self, head: ListNode):
    #     now = head
    #     p1 = None
    #     while now:
    #         p2 = now.next
    #         now.next = p1
    #         p1 = now
    #         now = p2
    #     return p1

#双指针
        fast, slow = head, head
        n = 0
        while n+1<k:
            fast = fast.next
            n += 1
        while fast.next:
            fast = fast.next
            slow = slow.next
        return slow