[LeetCode] Intersection of Two Linked Lists

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

A:          a1 → a2                   ↘                     c1 → c2 → c3                   ↗            B:     b1 → b2 → b3

begin to intersect at node c1.

Notes:

• If the two linked lists have no intersection at all, return null.
• The linked lists must retain their original structure after the function returns.
• You may assume there are no cycles anywhere in the entire linked structure.
• Your code should preferably run in O(n) time and use only O(1) memory.

要说在LeetCode上刷题最让我受益匪浅的地方，大概就是链表相关的问题了吧。以前对于链表的认识很浅，基本只够应付“说说链表和数组的优缺点”这种问题，真正应用到的机会很少。来了LeetCode才发现，链表还可以这么玩，而且玩的这么溜。

针对这道题，我想了很久都想不到O(n)时间复杂度的做法（我是真的菜），于是就撸了一个暴力枚举的做法：

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

毕竟跟指针相关的代码很容易出错，为了确认这样写的逻辑有没有问题，我就试探性地交了一发，居然直接AC了...这要是在ACM，怎么也是TLE吧。

感觉打ACM的人是不是真的不应该做LeetCode，做多了AC多了，你真的就没有对罚时的恐惧了，对时间复杂度也视而不见了...

当然这道题还没有结束，上面的代码明显不是最优的。想了一下其实用哈希基本就可以降复杂度了，于是乎再来一发：

/** * 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<ListNode*> s;        while(headA)        {            s.insert(headA);            headA=headA->next;        }        while(headB)        {            if(s.find(headB)!=s.end())return headB;            headB=headB->next;        }        return NULL;    }};

哈哈哈过了，用时也还算低，但是直觉告诉我这不是出题人的本意，肯定还有更巧妙的做法。果不其然，围观了一下大佬的做法，简直变身小迷弟给大佬疯狂打call。这是大佬的代码：

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

两个字：优美

题目保证不出现环，然后大佬就把两个链首尾相连构造成环。有两个理解上的要点：

• 假设A长度m,B长度n，两个指针都会在m+n次循环后同时抵达空指针，使得a!=b不成立退出循环，防止了死循环的出现，返回NULL。
• 假设倒数第k个点是交集，由于交点之后的点是共用的，所以两个指针都会在m+n-k次循环后抵达相同节点，使得a!=b不成立退出循环，返回交点指针。

如果大家理解上有困难，可以画个图模拟一下。这种想法光是理解对我们来说都挺费劲的，大佬还能用短短几行代码就将其实现，实在是让人佩服。

这道题也让我认识到，自己对指针、链表的认识还需要加强。