题目描述

给你两个单链表的头节点 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 。

提示：

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

进阶： 你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

思路

这道题要找出两个链表是否相交，并找出相交的节点。如果有相交的话，两个链表是一个Y形，我们不妨反过来想，从尾部开始，找到它们分叉的位置。首先，需要从尾部进行对齐，长的链表比短的链表多的那部分必不可能相交。之后从尾部开始，进行一个个比较，找到不等的地方，那么前一个相等的地方，就是交点了，如果一开始就不等，什么没有焦点。按照这个思路再返回来，就是需要我们做以下几件事，计算链表节点数，之后进行尾部对齐。对齐之后从头开始，找到相等的节点，如果到了末尾，就是没有节点。

除了上面的思路，判断链表的相交上的问题，很容易联想到数学上的追及问题。我们可以从这方面想一下。我们先假设链表是先相交的，Y形的三叉为x（假设x>=y）,y,z(公共部分)。两个个指针先各自从头走到尾，距离分别为x+z,和y+z,这样的话，如果让从长的再走一段y,从短的走一段x,那么两指针走的距离恰好相等，相遇点即为相交的地方。具体的走法，就是先各种从起点出发走到终点（路程为x+z,y+z）,到达终点后从另一个起点出发走（路程为y,x），两个指针走的距离都为x+y+z。

代码实现

尾对齐：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        int gap = lenA - lenB;
        while (gap--) {
            curA = curA->next;
        }                //尾对齐
        while (curA != NULL) {  //比较
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

追及问题：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *A = headA, *B = headB;
        while (A != B) {     
            A = A != nullptr ? A->next : headB;
            B = B != nullptr ? B->next : headA;
        }
        return A;
    }
};

总结

在链表上使用双指针，最最重要的一点是要挖掘出双指针的指向需要满足什么样的条件，才能符合我的要求。这道题针对了链表的相交在数学上可以处理为追及问题进行了讨论。