LeetCode T160.相交链表

思路一：

1. 先遍历链表A，记录链表A的长度lenA
2. 再遍历链表B，记录链表B的长度lenB
3. 如果lenA > lenB，让pA先走lenA - lenB步，使pA和pB指向相同位置；如果lenA < lenB，让pB先走lenB - lenA步
4. 同时遍历两个链表，直到找到相同位置（即交点）

代码：

# Definition for singly-linked list.
from typing import Optional

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        # 1. 先遍历链表A，记录链表A的长度lenA
        lenA = 0
        pA = headA
        while pA:
            lenA += 1
            pA = pA.next

        # 2. 再遍历链表B，记录链表B的长度lenB
        lenB = 0
        pB = headB
        while pB:
            lenB += 1
            pB = pB.next

        pA = headA
        pB = headB
        # 3. 若lenA > lenB，则让pA先走lenA - lenB步，使pA和pB指向相同位置
        if lenA > lenB:
            for i in range(lenA - lenB):
                pA = pA.next
        else:
            for i in range(lenB - lenA):
                pB = pB.next

        # 4. 同时遍历两个链表，直到找到相同位置
        while pA and pB:
            if pA == pB:
                return pA
            pA = pA.next
            pB = pB.next

        return None

 思路二：

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

• 头节点 headA 到 node 前，共有 a−ca - ca−c 个节点；
• 头节点 headB 到 node 前，共有 b−cb - cb−c 个节点；

 

考虑构建两个节点指针 A​ , B 分别指向两链表头节点 headA , headB ，做如下操作：

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

如下式所示，此时指针 A , B 重合，并有两种情况：a+(b−c)=b+(a−c)

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

因此返回 A 即可。

代码：

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