(笔记自用)LeetCode题目:相交链表

给你两个单链表的头节点 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
输出：null
解释：从各自的表头开始算起，链表 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]

 

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

题解:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

//方法一:依次比较遍历 
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if(!headA || !headB)
        return NULL;
    struct ListNode* A=headA;
    struct ListNode* B=headB;
    while(A!=NULL)  //为什么此处不能用!A?
    {
        while(B!=NULL)  //为什么此处不能用!B?
        {
            if(A==B)
                return B;
            else
                B=B->next;
        }
        A=A->next;
        B=headB;
    }
    return NULL;
}


// // 方法二:哈希表法--用例48中,当节点数过多时对于哈希冲突的处理超时
// // 思路:先构建一个哈希表,根据规则:  将A链表节点依次放入哈希表,
// //      再用B链表的元素依次进行比较,查看是否完全一致

//哈希表插入元素函数
void InsertHash(struct ListNode* node,struct ListNode* hash[])
{
    int temp=node->val;
    while(hash[temp]!=NULL)
        temp++;
    hash[temp]=node;
}

//哈希表比较函数
struct ListNode* CompareHash(struct ListNode* node,struct ListNode* hash[])
{
    int temp=node->val;
    while(hash[temp]!=NULL)
    {
        if(node==hash[temp])
            return node;
        temp++;
    }
    return NULL;
}

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* hash[100000];
    struct ListNode* A=headA;
    struct ListNode* B=headB;
    struct ListNode* ans;
    while(A!=NULL)
    {
        InsertHash(A,hash);
        A=A->next;
    }
    //将B链表节点依次进行比较
    while(B!=NULL)
    {
        ans=CompareHash(B,hash);
        if(ans!=NULL)
            return ans;
        B=B->next;
    }
    return NULL;
}


//方法三:双指针消除长度差法法
//基本思路：
//先遍历其中一个链表，当到底末端后跳到另一链表，最后
//若两链表没有公共结点，那么两个链表指针都会走过s1+s2个结点，同时到达两链表末尾
//若有公共结点，由于最后会同时走到两链表终点，所以倒退回去，两个指针一定会在第一个公共结点处相遇
//当然，若两链表等长，那确实不会跳到另一链表，不过链表等长本身指针就是同步的，同样也能找到公共结点

//基本思想:消除长度差
//当两个链表长度相同时,同时进行遍历,一次遍历就会找到公共节点;
//若链表长度不同,则每次遍历会缩减长度差,经过多次遍历后一定能相遇
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *pA = headA, *pB = headB;  
    while (pA != pB) //遍历,直到 pA 和 pB 相遇(（(即指向同一个节点),返回公共节点
    {  
        pA = (pA == NULL) ? headB : pA->next;  //当 pA 到达链表 A 的末尾时，将其重新指向链表 B 的头节点
        pB = (pB == NULL) ? headA : pB->next;  //当 pB 到达链表 B 的末尾时，将其重新指向链表 A 的头节点
    }  
    return pA;  //要么是公共节点,要么同时为NULL
}

//方法四:栈
//两个链表从公共结点开始后面都是一样的，若是我们顺着链表从后向前查找，
//很容易就能查找到链表的公共结点（第一个不相同的结点的下一个结点即所求）
//使用栈实现从后往前查找
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if(headA==headB)
        return headA;
    struct ListNode* stack1[30000];int top1=0;
    struct ListNode* stack2[30000];int top2=0;
    struct ListNode* A=headA;
    struct ListNode* B=headB;
    while(A!=NULL)
    {
        stack1[top1++]=A;
        A=A->next;
    }
    while(B!=NULL)
    {
        stack2[top2++]=B;
        B=B->next;
    }
    //查看最后一个节点是否是共同节点,若是则一定相交
    if(top1>=0 && top2>=0 && stack1[--top1]==stack2[--top2])
    {
      while(top1>=0 && top2>=0)
      {
        if(stack1[top1]!=stack2[top2])
            return stack1[top1]->next;
        top1--;top2--;
      }  
      //防止共同节点是0号节点,因为已经有共同交点了,所以前面如果都相同,那0号节点一定是交点
      return stack1[++top1];    
    }
    return NULL;
}


//方法五:计算长度差
//基本思路:将两个链表变成登场的链表再进行遍历,实现O(n) 时间复杂度，且仅用 O(1) 内存
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
   int size1 = 1, size2 = 1;
    struct ListNode *p, *q;

    if (!headA || !headB)
        return NULL;

    //计算链表长度
    for (p = headA; p->next != NULL; p = p->next, size1++);
    for (p = headB; p->next != NULL; p = p->next, size2++);

    //长链表先走，但不确定AB谁长，所以要写两个循环，但实际上只有长度较长的循环会执行
    p = headA;
    q = headB;
    for (int i = 0; i < size1 - size2; i++, p = p->next);
    for (int i = 0; i < size2 - size1; i++, q = q->next);

    //让长度较长的先走长度差个节点的距离后再同时遍历,这样就实现了两个链表同长进行遍历
    for (; p && q && p != q; p = p->next, q = q->next);

    return p;
}