力扣--160.相交链表（简单题）

有被昨天的中等题打击到，所以老老实实继续做简单题吧。

【题目描述】

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

如下面的两个链表：

在节点 c1 开始相交。

原题传送门

【示例】

示例 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 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 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。

注意：

如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

本来还有图示，但是嫌麻烦就不贴了，建议去 这里看。

【思路+代码】

一开始觉得好简单，不就是简单的搜索吗，先采用了最最暴力的方式：对A中的每个结点，遍历B中的每个结点进行判断，代码如下：

/**
 * 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) {
        if(headA==NULL || headB ==NULL){
            return NULL;
        }
        ListNode *a=headA;
        ListNode *ans=NULL;
        while(a!=NULL){
            ListNode *b=headB;
            while(b!=NULL){
                if(a==b){
                    return a;
                }
                b=b->next;
            }
            a=a->next;
        }
    return ans;
    }
};

运行结果：

显然，这种暴力的方式，非常费时间。
因此，我想能不能两个链表同时遍历呢？

但是，同时遍历两个链表时，有个问题需要考虑，那就是两个链表长度不一致该怎么办？答案就是：当遍历到末尾时，返回起点，再从头开始遍历，这样的话，只要它俩有交点，那一定就会相遇，而如果没有交点，那它俩也会出现同时为NULL的情况。假设A的长度为3，B的长度为4，那么当两个指针同时移动时，最多移动3*4=12次，就一定可以知道它们到底有没有相交，因为后面两个人都回到起点，等于重复之前的动作。因此，循环的条件就是：

a!=b//相交时就找到了答案，不相交则同时为NULL

下面是完整的代码：这个思路，在这题的解题区和评论区有很多种版本，还有很多大佬配上了有趣的注释，可以去看看，真的笑死哈哈哈哈。

/**
 * 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) {
        if(headA==NULL || headB ==NULL){
            return NULL;
        }
        ListNode *a=headA;
        ListNode *b=headB;
        while(a!=b){
            a=(a==NULL)?headA:a->next;
            b=(b==NULL)?headB:b->next;
        }
    return a;
    }
};

执行结果：

可以看到，和之前相比，时间消耗减少了近一半，空间消耗比较小。但是只击败了6%，再看看大佬们的解题思路吧。

看到一个大佬的解答：这里

照着这个思路写了写代码：

/**
 * 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) {
        if(headA==NULL || headB ==NULL){
            return NULL;
        }
        ListNode *a=headA;
        ListNode *b=headB;
        int la=0,lb=0;
        //统计长度
        while(a->next!=NULL){
            la++;
            a=a->next;
        }
        while(b->next!=NULL){
            lb++;
            b=b->next;
        }
        a=headA;
        b=headB;
        int k=0;
        if(la>lb){//A更长
        k=la-lb;
        while(k--)//A先走
        a=a->next;
        }
        else if(la<lb){//B更长
        k=lb-la;
        while(k--)//B先走
        b=b->next;
        }
        while(a!=b){
           a=a->next;
           b=b->next;
        }
    return a;
    }
};

结果果然快了很多！！

想起来其实大二上数据结构的时候，老师讲链表时讲到过这个思路，只是太久没看，做题的时候搞忘了，果然只是还是要常巩固啊！