Leetcode刷题营第十五题：相交链表

160. 相交链表

相关

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

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

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

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

自定义评测：

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

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

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

示例 1：

输入：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 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,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
输出：No intersection
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 1 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

思路一：长度对齐法，遍历两链表，节点指向的地址相同则为交叉节点

        两个链表，两个头指针，我们先分别遍历这两个链表得到它们各自的链表长度m,n。我么先让长的链表进行遍历，遍历两个长度的差值之后，然后一同进行遍历。当两个链表遍历到的节点指针同时指向同一个地址。那么我们返回这个节点的指针 --> “交叉指针”

代码实现：

SListNode *getIntersectionNode(SListNode *headA, SListNode *headB) {
    if(headA == NULL || headB == NULL){
        return NULL;
    }   
    int count_A = 0;
    int count_B = 0;
    SListNode* Cur_A = headA;
    SListNode* Cur_B = headB;
    while (Cur_A)
    {
        count_A++;
        Cur_A = Cur_A->next;
    }
    while (Cur_B)
    {
        count_B++;
        Cur_B = Cur_B->next;
    }
    SListNode* Cur_A = headA;
    SListNode* Cur_B = headB;

    while (Cur_A && Cur_B)
    {
        if(count_A > count_B){
            Cur_A = Cur_A->next;
            count_A--;
        }
        else if(count_A < count_B){
            Cur_B = Cur_B->next;
            count_B--;
        }
        else{
            if(Cur_A == Cur_B){
                return Cur_A
            }
            Cur_A = Cur_A->next;
            Cur_B = Cur_B->next;
        }
    }
    return NULL
}

思路二：利用双指针遍历两个链表

       两个链表，两个头指针进行遍历，当第一个指针指向第一个链表的尾端时，把第二个链表的头指针给到这个指针，同理第二个指针指向第二个链表的尾端时，把第一个链表的头指针给到第二个指针。

我们用两个指针 pA 和 pB 分别遍历两个链表：

pA 从链表 A 开始，走到末尾后跳到链表 B 的头；

pB 从链表 B 开始，走到末尾后跳到链表 A 的头；

这样两个指针走过的总长度是一样的：lenA + lenB。如果两个链表相交，两个指针最终会在 第一个相交节点 相遇；如果不相交，两个指针都会走到 NULL，并在那一刻相等，退出循环。

思路图如下：

代码如下：

SListNode *getIntersectionNode(SListNode *headA, SListNode *headB){
    if(headA == NULL || headB == NULL){
        return NULL;
    }
    SListNode* pA = headA;
    SListNode* pB = headB;
    while (pA != pB)
    {
        pA = pA ? pA->next : headB; //走到链表末尾跳转到链表b
        pB = pB ? pB->next : headA  ; //走到链表末尾跳转到链表a
    }
    return pA;
    
}

算法时间复杂度,m,n分别是两个链表的长度，空间复杂度。

谢谢大家的点赞收藏！！