剑指 Offer 52. 两个链表的第一个公共节点

思路

方法一：暴力法

方法二：哈希表

方法三：双指针之一

(1) 遍历链表A, B，计算出他们分别的长度lenA, lenB。

(2) 链表长的指针向后移动到俩个链表长度差的位置。

(3) 之后一一进行比较。

复杂度分析

时间复杂度：O(lenA + lenB)

空间复杂度：O(1)

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 class Solution {
10 public:
11     ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
12         if(headA == NULL ||  headB == NULL)
13             return NULL;
14 
15         int lenA = 0, lenB = 0;
16         ListNode *p;
17         p = headA;
18         while(p != NULL) {
19             lenA++;     //计算链表A的长度
20             p = p->next;
21         }
22 
23         p = headB;
24         while(p != NULL) {
25             lenB++;     //计算链表B的长度
26             p = p->next;
27         }
28 
29         ListNode *pa = headA, *pb = headB;
30         if(lenA >= lenB) {
31             int diff = lenA-lenB;
32             for(int i = 0; i < diff; ++i) {
33                 pa = pa->next;  //A先走diff步
34             }
35 
36         } else {
37             int diff = lenB-lenA;
38             for(int i = 0; i < diff; ++i) {
39                 pb = pb->next;  //B先走diff步
40             }
41         }
42 
43         while(pa != pb) {   //之后一起走
44             pa = pa->next;
45             pb = pb->next;
46         }
47         
48         return pa;
49     }
50 };

方法四：双指针之二 (推荐)

设链表A的不同部分长度为n(不包括交点), 链表B不同部分长度为m (不包括交点), 两链表相同部分长度为t(包括交点);

根据加法结合律，有：(n + t) + m = (m + t) + n，即：lenA + m = lenB + n。

则：我们使用两个指针pa，pb分别指向两个链表的头结点 headA，headB，然后同时分别逐结点遍历，当 pa 到达链表A的末尾时，重新定位到链表B的头结点headB；当 pa 到达链表B的末尾时，重新定位到链表A的头结点headA。

这样，当它们相遇时，所指向的结点就是第一个公共结点。如下图C1:

对于两链表无交点的情况，如果令pa -> next == NULL时将其重新定位到headB，pb->next == NULL时将其重新定位到headA，将会死循环，两者永远不会相遇。如下图，

为了方便编程，使得其与上述情况一样，可以将NULL视为它们的交点，此时编程的时候就要令，当 pa == NULL时，将其重新定位到headB，而不是pa -> next == NULL时将其重新定位到headB；pb同理。

最后pa和pb将在NULL处相遇。

复杂度分析

时间复杂度：O(lenA + lenB)

空间复杂度：O(1)

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 class Solution {
10 public:
11     ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
12         ListNode *pa = headA, *pb = headB;
13         while(pa != pb) { 
14             //这里不能写if(pa->next == NULL),否则无法判定两链表无交点的情况
15             if(pa == NULL) 
16                 pa = headB;
17             else 
18                 pa = pa->next;
19             
20             //这里不能写if(pb->next == NULL),否则无法判定两链表无交点的情况
21             if(pb == NULL) 
22                 pb = headA;
23             else 
24                 pb = pb->next;
25             
26         }
27         
28         return pa;
29     }
30 };

方法五：双指针之三

此方法原理见：单链表中的环涉及到的6个相关问题

复杂度分析

时间复杂度：O(lenA + lenB)

空间复杂度：O(1)

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode(int x) : val(x), next(NULL) {}
 7  * };
 8  */
 9 class Solution {
10 public:
11     ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
12         if(headA == NULL ||  headB == NULL)
13             return NULL;
14 
15         ListNode *tailA = headA;
16         while(tailA->next != NULL) {
17             tailA = tailA->next;
18         }
19 
20         tailA->next = headA;    //令链表A循环
21 
22         ListNode *fast, *slow; 
23         if(headB->next == NULL) {
24             tailA->next = NULL; //恢复原链表的结构
25             return NULL;
26         } else {
27             slow = headB->next;
28             fast = headB->next->next;
29         }
30 
31         while(fast != slow) {
32             //由于链表A已经成环，如果此时slow为NULL，可以说明链表A,B无交点
33             if(slow->next == NULL || fast->next == NULL || fast->next->next == NULL)  {
34                 tailA->next = NULL; //恢复原链表的结构
35                 return NULL;
36             }
37             
38             slow = slow->next;
39             fast = fast->next->next; 
40         }
41 
42         ListNode *pb = headB;
43         while(pb != slow) {
44             slow = slow->next;
45             pb = pb->next;
46         }
47         
48         tailA->next = NULL; //恢复原链表的结构
49         
50         return slow;
51     }
52 };