Leetcode .160(相交链表)

编写一个程序，找到两个单链表相交的起始节点。
示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

一开始拿到题，我第一个想的就是用哈希表存一下表A的数，然后再在表B里找，写了一下发现要双循环了。时间复杂度成O(n²)了。

**方法一：**先把两个链表的长度求出来，要是长度不同，就调整指针，让他们齐头并进。代码如下：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA==NULL||headB==NULL)return NULL;
        ListNode *a=headA;
        ListNode *b=headB;
        int la=0,lb=0;
        while(a!=NULL){
            la++;a=a->next;
        }
        while(b!=NULL){
            lb++;b=b->next;
        }
        a=headA;b=headB;
        if(la>lb){
            for(int i=0;i<(la-lb);i++){
                a=a->next;
            }
        }
        else{
            for(int i=0;i<(lb-la);i++){
                b=b->next;
            }
        }
        while(a!=b){
            a=a->next;
            b=b->next;
        }
        return a;
    }
};

**方法二：**在评论里发现一个大神的解法：
主要分以下几种情况：

先对长度相同的链表进行讨论：
1.长度相同且没有交点：
只需进行一轮循环，A,B同时到达链表末尾。A=B=NULL，此时不满足while循环条件，因此退出循环，返回NULL；
2.长度相同且有交点：
只需进行一轮循环，A,B的进度一样，同时达到交点处，A=B!=NULL，此时不满足while的循环条件，因此退出循环，返回交点。

然后是对长度不同的链表进行讨论：
对于长度不同的链表，要想办法让A,B两个指针像长度相同时一样，齐头并进。所以需要对其进行两轮循环，第一轮循环就是用来调整A,B的位置的。由于长度不同，所以短的链表指针先走到链表末尾，A,B两者之间的差异就是链表长度的差异，所以此时让短的去走长的走过的路。也就是A,B指针走完一轮后换一下所指的链表。这样二者最后加起来走的总路数就相同了。
3.长度不同且没有交点
进行两轮循环。直到最后A=B=NULL，退出循环， 返回NULL；
4.长度不同且有交点
进行两轮循环，让快的等等慢的，最后总能在交点之前二者齐头并进。找到交点，A=B!=NULL，退出循环，返回交点。

代码如下：

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

方法三：快慢指针法。
就是把一个链表链成一个环，然后用快慢指针进行搜索，如果最后两个指针可以碰到一起，就说明存在环，也就是存在交点。
如果存在交点，还要找到交点所在的位置，此时让一个指针回到表头，可以发现二者距离交点的距离是一样的。（公式证明还没搞懂） (见环形链表博客)
但是时间复杂度就变成了O(n²)
代码如下：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA==NULL||headB==NULL)return NULL;
        ListNode *a=headA;//慢指针
        ListNode *b=headB;//快指针
        ListNode *last=headB;
        while(last->next!=NULL){
            last=last->next;
        }
        last->next=headB;
        while(b!=NULL&&b->next!=NULL){
            a=a->next;
            b=b->next->next;
            if(a==b){
                a=headA;
                while(a!=b){
                    a=a->next;
                    b=b->next;
                }
                last->next=NULL;
                return b;
            }
        }
        last->next=NULL;
        return NULL;
    }
};