【链表】力扣160：相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

哈希表

判断两个链表是否相交，可以使用哈希集合存储链表结点。

• 首先遍历链表 headA，并将每个结点加入哈希集合中。key 为当前结点，value 为其后继结点

• 然后遍历链表 headB，对于遍历到的每个结点，判断该结点是否在哈希集合中：

  • 如果当前结点不在哈希集合中，则继续遍历下一个结点

  • 如果当前结点在哈希集合中，则后面的结点都在哈希集合中，即从当前结点开始的所有结点都在两个链表的相交部分，因此在链表 headB 中遍历到的第一个在哈希集合中的结点就是两个链表相交的结点，返回该结点

  • 如果链表 headB 中的所有结点都不在哈希集合中，则两个链表不相交，返回 null(None)

# 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:
        ht = [] # 建哈希表
        # 用指针遍历链表 headA 使之存储到哈希表中：键为当前结点，值为其后继结点
        p = headA
        while p != None:
            ht.append(p)
            p = p.next
        # 用指针遍历链表 headB
        p = headB
        while p != None:
            if ht.count(p): # 判断 headB 中的结点是否已经作为 key 出现在哈希表中，即 headB 中是否有 headA 中的结点。有则返回当前结点 p
                return p
            p = p.next
        return None

时间复杂度：O(m + n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。需要遍历两个链表各一次。

空间复杂度：O(m)，其中 m 是链表 headA 的长度。需要使用哈希集合存储链表 headA 中的全部结点。

双指针

使用哈希表的空间复杂度有点高，为将空间复杂度降至 O(1)可以使用双指针的方法。

参考：https://leetcode.cn/problems/intersection-of-two-linked-lists/solution/intersection-of-two-linked-lists-shuang-zhi-zhen-l/

• 只有当链表 headA 和 headB 都不为空时，两个链表才可能相交。因此首先判断链表 headA 和 headB 是否为空，如果其中至少有一个链表为空，则两个链表一定不相交，返回 null

• 当链表 headA 和 headB 都不为空时，创建两个指针 pa 和 pb，初始时分别指向两个链表的头结点 headA 和 headB，然后将两个指针依次遍历两个链表的每个结点

  • 如果指针 pa 不为空，则将指针 pa 移到下一个结点；如果指针 pb 不为空，则将指针 pb 移到下一个结点

  • 如果指针 pa 为空，则将指针 pa 移到链表 headB 的头结点；如果指针 pb 为空，则将指针 pb 移到链表 headA 的头结点

设「第一个公共节点」为 node，链表 headA 的节点数量为 a，链表 headB 的节点数量为 b，「两链表的公共尾部」的节点数量为 c，则有：

• 头节点 headA 到 node 前，共有 a − c 个节点

• 头节点 headB 到 node 前，共有 b − c 个节点

• 指针 pa 先遍历完链表 headA，再开始遍历链表 headB，当走到 node 时，共走步数为 a + (b − c)

• 指针 pb 先遍历完链表 headB，再开始遍历链表 headA，当走到 node 时，共走步数为 b + (a - c)

此时指针 pa, pb 重合，$ a + (b − c) = b + (a - c) $，并有两种情况：

1. 若两链表 有公共尾部 (c > 0) ：指针 pa, pb 同时指向「第一个公共结点」node
2. 若两链表 无公共尾部 (c = 0) ：指针 pa, pb 同时指向 null

因此，返回 指针pa 即可。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        # 先考虑特殊情况
        if headA == None or headB == None:
            return None
        pa, pb = headA, headB # 创建双指针
        while pa != pb:
            '''
            if pa: 指针 pa 不为空。此时将指针 pa 移到下一个结点
            else: 指针 pa 为空，说明已经遍历完链表 headA，然后开始遍历链表 headB，则 pa = headB，使 pa 指向 headB 的头结点
            '''
            pa = pa.next if pa else headB
            pb = pb.next if pb else headA
        return pa

时间复杂度：O(m + n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。

空间复杂度：O(1)。

标签：力扣,结点,链表,pa,headB,headA,160,节点
来源： https://www.cnblogs.com/Jojo-L/p/16462758.html