LC160. 相交链表

题目

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

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

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

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

自定义评测：

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

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

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

• 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]

思路

返回值：

• 若存在相交节点，返回第一个相交节点的指针
• 若不存在相交节点，返回nullptr

哈希

可以采用哈希集合存储一个链表的节点地址信息，再拿另一个链表节点进行对比

• 采用unordered_set循环存储headA中每一个指向节点的指针信息，这里采用longlong存储，也可以直接使用ListNode *结构。
• 依次与headB每个节点的地址信息进行对比，若headB某个节点在哈希集合中存在，则返回该节点。
• 若headB没有一个相同节点，则返回空指针。
• 时间复杂度：O(m+n)
• 空间复杂度：O(m)

双指针

哈希的方式空间复杂度较高，且无法提前判断headA和headB哪个节点数更少而做出优化。
根据题目要求，A和B有最后一部分是相同的（可能为空）而之前都是不同的。
为了能让两个指针从头开始同一时间到达交叉位置，有两种可能性：

• 采用快慢指针，一个走得慢，一个走得快：这里找不到此规律
• 两个指针走相同路程：A和B交叉之前路程大部分情况是不同的，怎么能让他们走一样的路呢？

这里假设headA有6个节点，headB有5个节点，其中后三个节点是相同的。
我们可以把这种指针相遇问题转化成走路问题，A和B开始走不一样的路，最后走到一条路上，我们要做的就是让他们相遇。
为了让他们相遇前走相同的路径，可以让headA走完它自己3个节点再走headBd的前两个节点，headB同理。此时我们发现他们就走了相同路径，能同时走到交叉节点并相遇。
但是我们并不事先知道在哪里是交叉节点，所以无法知道headA走到哪里开始走headB的路这里可以把这种思路从局部考虑换成全局考虑：
headA先把自己所有路（节点）走完，再去走headB的路（节点）。headB也是先把自己所有路（节点）走完，再去走headA的路（节点）。最后可以发现他们走的路是一样多的，那就说明在结尾他们一定相遇的，那也就说明在这共同的一条路（共同的节点）上他们一直是一起走的，那也就说明他们同一时间到达了交叉节点处。
可用图来表示：

• 时间复杂度：O(m+n)
• 空间复杂度：O(1)

代码

/**
 * 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) {
        // 哈希表
        // unordered_set<long long> uset;
        // while(headA!=nullptr){
        //     uset.emplace((long long)headA);
        //     headA = headA->next;
        // }
        // while(headB!=nullptr){
        //     if(uset.count((long long)headB))
        //         return headB;
        //     headB = headB->next;
        // }

        //双指针
        ListNode* hA;
        hA = headA;
        ListNode* hB;
        hB = headB;
        while(headA!=headB){
            headA = headA->next;
            headB = headB->next;
            if(headA==headB) break;
            else if(headA==nullptr) headA = hA;
            else if(headB==nullptr) headB = hB;
        } 
        return headA;
    }
};