Leetcode：面试题 02.07. 链表相交（C++）

目录

问题描述

实现代码

---

问题描述：

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

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

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

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

示例 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 。

实现代码：

双指针法

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        ListNode* curA=headA;
        ListNode* curB=headB;
        int lenA=0;
        int lenB=0;
        //求A的表长
        while(curA)
        {
            lenA++;
            curA=curA->next;
        }
        //求B的表长
        while(curB)
        {
            lenB++;
            curB=curB->next;
        }
        curA=headA;
        curB=headB;
        //尾对齐
        if(lenA>lenB)
        {
            int gap=lenA-lenB;
            while(gap--)
            {
                curA=curA->next;
            }
        }
        else
        {
            int gap=lenB-lenA;
            while(gap--)
            {
                curB=curB->next;
            }
        }
        while(curA!=NULL)
        {
            if(curA==curB)
            {
                return curA;
            }
            curA=curA->next;
            curB=curB->next;
        }
        return NULL;

    }
};

原理就是求出两个链表的长度，然后尾对齐两个链表，将两个遍历指针cur再对齐，然后一起移动，当curA==curB的时候，就代表指向了相交的结点，这题注意是指针相等，而不是结点里的值相等。（这里我描述为两个链表是不准确的，其实是以两个不同头节点开始遍历出的链表，不过在这里，为了方便解释，就说是两个链表了）。画了一张原理图，其实也不用画，根据文字描述其实也就明白了。

 其实上面的代码是写复杂了，还有一种原理一样，但是代码更简洁的方法，下面给出。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        if(headA==NULL||headB==NULL)
        {
            return NULL;
        }
        ListNode* curA=headA;
        ListNode* curB=headB;
        while(curA!=curB)
        {
            curA=curA==nullptr?headB:curA->next;
            curB=curB==nullptr?headA:curB->next;
        }
        return curA;

    }
};

假设A，B两个链表相交，A链表长a，B链表长b，公共部分为c，A走完走B，B走完走A。

若相交，在第二次走到公共结点前curA走了a+(b-c)，curB走了b+(a-c)，可以发现a+(b-c)=b+(a-c)，所以两链表会同时到达相交之处。

若不相交，curA走了a+b，curB走了b+a，最后也会同时走到NULL。