题目链接

Leetcode.剑指 Offer II 023. 两个链表的第一个重合节点 easy

题目描述

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

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

示例 1：

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

示例 2：

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

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• $0<=m,n<=3\ast 10^4$
• $1<=Node.val<=10^5$
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal为 0
• 如果 listA 和 listB 有交点，$intersectVal==listA[skipA+1]==listB[skipB+1]$

分析：双指针

有交点的情况：

我们发现：

• 指针a从 headA出发，一直走，如果a指向null了，就将 a重新指向为 headB。当指针 a第二次走到交点时，走过的距离为 x + z + y
• 指针b从 headB出发，一直走，如果b指向null了，就将 b重新指向为 headA。当指针 b第二次走到交点时，走过的距离为 y + z + x

即，两个指针按照以上的走法的话，他们是一定会在交点相遇的。

没有交点的情况：

两个指针 a和 b还是按照之前的走法，当他们走过 x+y的距离时，他们会同时指向 null。

时间复杂度： $O(n)$

C++代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA == nullptr || headB == nullptr) return nullptr;
        ListNode *a = headA , *b = headB;
        while(a != b){
            a = (a == nullptr ? headB : a->next);
            b = (b == nullptr ? headA : b->next);
        }
        return a;
    }
};

Python代码：

# 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:
        if not headA or not headB:
            return None
        a , b = headA , headB
        while a != b:
            a = headB if a==None else a.next
            b = headA if b==None else b.next
        return a