相交链表（c语言）

1.
///给你两个单链表的头节点 headA 和 headB ，
//请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 
//题目数据 保证 整个链式结构中不存在环。
//注意，函数返回结果后，链表必须 保持其原始结构 。
// 输入：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 中第四个节点) 在内存中指向相同的位置。
//输入：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 个节点。
//输入：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 。

2./方法一：暴力求解（pool举）将headA的值于headB的值进行一一比较找到地址相等的时候。(比较简单)

//*Definition for singly - linked list.
 struct ListNode {
    int val;
    struct ListNode* next;
    
};
 //方法一：暴力求解（pool举）将headA的值于headB的值进行一一比较找到地址相等的时候。
  struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
     struct ListNode* taila = headA;
     struct ListNode* tailb = headB;
     int leta = 0;
     int letb = 0;
 //找到尾节点记录他们的长度
 while (taila->next)
 {
     taila = taila->next;
     leta++;
 }
 while (tailb->next)
 {
     tailb = tailb->next;
     letb++;
 }
 struct ListNode* heada= headA;
 for (int i = 0; i < leta;i++)
 {
     struct ListNode* headb = headB;
     for (int i = 0; i < letb; i++)
     {
         if (heada == headb)
         {
             goto end;
         }
         headb = headb->next;
     }
     heada = heada->next;
 }
return 0;
end:
while(heada!=headb)
{
    heada=heada->next;
    headb=headb->next;
}
 return 1;
}

3. //方法二：（判断地址是否相等）当尾节点相等就是相交，否则不相交,第一步我们找到尾节点记录二个链表长度(leta,letb)，然后判断尾节点是否相等，如果相等，则就相交，反之则不相交则返回NULL。二个链表长度不相等先判断长的链表，长的链表（longhead）先走gap=|leta-letb|步，判断后面的地址是否相等，如果后面地址不相等，则返回false，相等则true。（只要函数，无二个长度链表）

//*Definition for singly - linked list.
 struct ListNode {
    int val;
    struct ListNode* next;
    
};
struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
    struct ListNode* taila = headA;
    struct ListNode* tailb = headB;
    int leta = 0;
    int letb = 0;
    //找到尾节点记录他们的长度
    while (taila->next)
    {
        taila = taila->next;
        leta++;
    }
    while (tailb->next)
    {
        tailb = tailb->next;
        letb++;
    }
    当尾节点相等就是相交，否则不相交
    if (taila != tailb)
    {
        return NULL;
    }
    //长的先走gap步
    int gap = abs(leta - letb);
    //假设a的长度大于b的长度
    struct ListNode* longhead = headA;
    struct ListNode* shorthead = headB;
    if (leta < letb)
    {
        longhead = headB;
        shorthead = headA;
    }
    while (gap--)
    {
        longhead = longhead->next;
    }
    while (longhead != shorthead)
    {
        longhead = longhead->next;
        shorthead = shorthead->next;
    }
    return longhead;
}