面试100题：7.判断两个链表是否相交

题目：

给出俩个单向链表的头指针，比如h1，h2，判断这俩个链表是否相交。

为了简化问题，我们假设俩个链表均不带环。

分析：

之前一直没有搞清楚的问题，今天看了如下链接才终于有了清晰的认识，一个字就是笨，俩字很笨，三字非常笨。

参考：http://blog.163.com/bbluesnow@126/blog/static/27784545201251051156817/。特此感谢！！！

先要搞清楚如下几个问题，就能看透此题的真面目，才能体会到此题居然可以挖掘的这么深。

1)判断一个单链表是否有环

在一个单链表上判断有没有环的首选方法就是采用快慢步长法。分别令两个指针p和q分别指向头节点，p指针每次前

进一步，q指针每次前进两步。如果最终p和q指针能够指向同一个节点，则说明有环。

证明：

假设p和q的速度分别为v1和v2，如果存在环，我们假设指针p和q第一次进入环时，他们相对于环中第一个节点

的偏移地址分别为a和b（偏移地址即为节点数）。

这样判断链表是否有环就转化为p和q指针的值是否存在相等的时候，也就是他们相对于环的首节点的偏移量是

一样的。设环的节点个数为n，程序可能循环了m次。

这样就会有如下等式：(a+m*v1)mod(n)=(b+m*v2)mod(n)

假设p指针mod(n)的最大整数位k1，q指针mod(n)的最大整数位k2，则(a+m*v1)-k1*n= (b+m*v2)-k2*n，整理后得

m=|((k2-k1)*n+a-b)/(v2-v1)| , v2>v1。

时间复杂度分析：

假设甩尾（在环外）长度为len1（结点个数），环内长度为 len2，链表总长度为n，则n=len1+len2 。当p步

长为1，q步长为2时，p指针到达环入口需要len1时间，p到达入口后，q处于哪里不确定，但是肯定在环内，此

时p和q开始追赶，q最长需要len2时间就能追上p（p和q都指向环入口），最短需要1步就能追上p（p指向环入口，

q指向环入口的前一个节点）。事实上，每经过一步，q和p的距离就拉近一步，因此，经过q和p的距离步就可以

追上p。因此总时间复杂度为O(n)，n为链表的总长度。

1. // 1) 判断一个单链表是否有环  
2. template<typename T>  
3. bool checkCircle(T* head)  
4. {  
5.     if (NULL == head)  
6.         return false;  
7.     T* low = head;  
8.     T* fast = head;  
9.     while (low->next != NULL && (fast->next != NULL) && (fast->next)->next != NULL)  
10.     {  
11.         low = low->next;  
12.         fast = (fast->next)->next;  
13.         if (low == fast)  
14.         {  
15.             return true;  
16.         }  
17.     }  
18.     return false;  
19. }  

2)判断一个环的入口点位置

证明：

链表形状类似数字6。假设环外长度（节点数）为a，环内长度为b，则总长度（链表总节点数）为a+b。起始节

点编号，从0开始。假设第i步访问的节点为S(i)，i=0,1,2...n。当i<a时，S(i)=i;当i>=a时，S(i)=a+(i-a)%b。

分析追赶过程：

p和q指针分别从头节点以v1和v2速度前进，经过x步后碰撞，则有：S(x)=S(2x)。由于环的周期性存在

如下等式：2x=tb+x，得x=tb。碰撞时，必须发生在环内，所以有x>=a。

入口点为从起点走a步，即S(a)。S(a)=S(tb+a)=S(x+a)

结论：从碰撞点x前进a步即为环的入口点。

假设分别从起点和x点同时前进，第一个碰撞点就是环的入口点。

时间复杂度分析：

假设甩尾（在环外）长度为len1（结点个数），环内长度为 len2 。则时间复杂度为“环是否存在的时间复杂度”+O（len1）。

1. // 2) 查找环的入口  
2. template<typename T>  
3. T* findLoopPort(T* head)  
4. {  
5.     // 判断是否有环，五环返回NULL  
6.     if (!checkCircle(head))  
7.         return NULL;  
8.     T* low = head;  
9.     T* fast = head;  
10.     // low按照步长1增加，fast按照步长2增加，找到碰撞点  
11.     while (1)  
12.     {  
13.         low = low->next;  
14.         fast = fast->next->next;  
15.         if (low == fast)  
16.             break;  
17.     }  
18.    
19.     // 分别从头结点和碰撞节点开始按照步长1增加，遍历链表，第一个节点相同的点是环入口点  
20.     low = head;  
21.     while (low != fast)  
22.     {  
23.         low = low->next;  
24.         fast = fast->next;  
25.     }  
26.     return low;   
27. }  

3) 环的长度

从碰撞点开始，两个指针p和q，q以一步步长前进，q以两步步长前进，到下次碰撞所经过的操作次数即是环的长度。这很好理解，比如两个运动员A和B从起点开始跑步，A的速度是B的两倍，当A跑玩一圈的时候，B刚好跑完两圈，A和B又同时在起点上。此时A跑的长度即相当于环的长度。

时间复杂度分析：

假设甩尾（在环外）长度为len1（结点个数），环内长度为 len2 ，则时间复杂度为“环是否存在的时间复杂度”+O(len2)。

1. // 3) 计算环的长度  
2. template<typename T>  
3. int getLoopLength(T* head)  
4. {  
5.     if (!checkCircle(head))  
6.         return 0;  
7.    
8.     T* low = head;  
9.     T* fast = head;  
10.     int length = 0;  
11.     // low按照步长1增加，fast按照步长2增加，找到碰撞点,然后接着循环直到下一次碰撞，  
12.     // 计算两次碰撞之间的循环次数即为长度  
13.     while (1)  
14.     {  
15.         low = low->next;  
16.         fast = fast->next->next;  
17.         if (low == fast)  
18.             break;  
19.     }  
20.     while(1)  
21.     {  
22.         low = low->next;  
23.         fast = fast->next->next;  
24.         length++;  
25.         if (low == fast)  
26.             break;  
27.     }  
28.     return length;  
29. }  

4)除环之外的链表长度

1. // 4) 计算有环链表的尾长度  
2. template<typename T>  
3. int getTailLength(T* head)  
4. {  
5.     T* port = findLoopPort(head);  
6.     int length = 0;  
7.     T* temp = head;  
8.     while (temp != port)  
9.     {  
10.         length++;  
11.         temp = temp->next;  
12.     }  
13.     return length;  
14. }  

5)判断两个（无环）单链表是否相交

法一：

将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个新链表。问题转化为求这个新链表是否有环的问题。时间复杂度：为环是否存在的时间复杂度，即O（length(A)+length(B)），使用了两个额外指针。

法二：

两个链表相交，则从相交的节点起，其后的所有的节点都是都是两个链表共有的。因此，如果它们相交，则最后一个节点一定是共有的。因此，判断两链表相交的方法是：遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交。

时间复杂度：O（length(A)+length(B)），但是只用了一个额外指针存储最后一个节点。

1. // 若都无环，b1==b2==0,尾节点必然相同，是Y字形  
2.     if (!b1)  
3.     {  
4.         while (head1->next != NULL) // 原来的代码head1 != NULL，此处改为head1->next != NULL。因为head1和head2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误  
5.         {  
6.             head1 = head1->next;  
7.         }  
8.         while (head2->next != NULL) // 原来的代码head2 != NULL，此处改为head2->next != NULL。因为head1和head2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误  
9.         {  
10.             head2 = head2->next;  
11.         }  
12.         if (head1 == head2)  
13.         {  
14.             return true;  
15.         }  
16.     }  

6) 如两个（无环）单链表相交，求相交的第一个节点

将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个环。问题转化为求这个环的入口问题。

时间复杂度：求环入口的时间复杂度。

1. // 若都无环，b1==b2==0,尾节点必然相同，是Y字形  
2.     if (!b1)  
3.     {  
4.         T* node1 = head1;  
5.         T* node2 = head2;  
6.         while (node1->next != NULL)// 原来的代码node1 != NULL，此处改为node1->next != NULL。因为node1和node2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误  
7.         {  
8.             node1 = node1->next;  
9.         }  
10.         while (node2->next != NULL)// 原来的代码node2 != NULL，此处改为node2->next != NULL。因为node1和node2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误  
11.         {  
12.             node2 = node2->next;  
13.         }  
14.         if (node1 == node2)  
15.         {  
16.             // 相交，把第一个链表的尾节点指向第二个链表  
17.             node1->next = head2;  
18.             junctionNode = findLoopPort(head1);  
19.             return true;  
20.         }  
21.     }  

7) 判断两个（有环）单链表是否相交

分别判断两个链表A、B是否有环。

如果仅有一个有环，则A、B不可能相交。如果相交，则该环必定是A、B共享。

如果两个都有环，则求出A的环入口，判断其是否在B链表上，如果在，则说明A、B相交。

时间复杂度："环入口问题的时间复杂度"+O(length(B))。

见8)

8) 如两个（有环）单链表相交，求相交的第一个节点

分别计算出两个链表A、B的长度LA和LB（环的长度和环到入口点长度之和就是链表长度），参照上面问题3)。

如果LA>LB，则链表A指针先走LA-LB，链表B指针再开始走，则两个指针相遇的位置就是相交的第一个节点。

如果LB>LA，则链表B指针先走LB-LA，链表A指针再开始走，则两个指针相遇的位置就是相交的第一个节点。

时间复杂度：O(max(LA,LB))

1. // 若有环，则找出链表1的环入口，看是否在链表2上  
2.     if (b1)  
3.     {  
4.         int length1 = getLoopLength(head1) + getTailLength(head1);  
5.         int length2 = getLoopLength(head2) + getTailLength(head2);  
6.         int len = length2;  
7.         T* port = findLoopPort(head1);  
8.         if (port != NULL)  
9.         {  
10.             T* temp = head2;  
11.             while (port != temp && (len--) >= 0)  
12.                 temp = temp->next;  
13.             if (port == temp)  
14.             {  
15.                 // 若长度相等，同步寻找相同的节点  
16.                 if (length1 == length2)  
17.                 {  
18.                     while (head1 != head2)  
19.                     {  
20.                         head1 = head1->next;  
21.                         head2 = head2->next;  
22.                     }  
23.                     junctionNode = head1;  
24.                 }  
25.                 // 若长度不等，长的先剪掉长度差，然后再同步递增  
26.                 else if (length1 > length2)  
27.                 {  
28.                     int step = length1 - length2;  
29.                     while (step--)  
30.                     {  
31.                         head1 = head1->next;  
32.                     }  
33.                     while (head1 != head2)  
34.                     {  
35.                         head1 = head1->next;  
36.                         head2 = head2->next;  
37.                     }  
38.                     junctionNode = head1;  
39.                 }  
40.                 else  
41.                 {  
42.                     int step = length2 - length1;  
43.                     while (step--)  
44.                     {  
45.                         head2 = head2->next;  
46.                     }  
47.                     while (head1 != head2)  
48.                     {  
49.                         head1 = head1->next;  
50.                         head2 = head2->next;  
51.                     }  
52.                     junctionNode = head1;  
53.                 }  
54.                 return true;  
55.             }  
56.             else  
57.             {  
58.                 return false;  
59.             }  
60.         }  
61.     }  

完整代码：

1. /*Title:    7.判断俩个链表是否相交 
2. Date:        2012-11-12*/  
3.    
4. #include <iostream>  
5. #include <string>  
6. #include <list>  
7. using namespace std;  
8.    
9. // 1) 判断一个单链表是否有环  
10. template<typename T>  
11. bool checkCircle(T* head)  
12. {  
13.     if (NULL == head)  
14.         return false;  
15.     T* low = head;  
16.     T* fast = head;  
17.     while (low->next != NULL && (fast->next != NULL) && (fast->next)->next != NULL)  
18.     {  
19.         low = low->next;  
20.         fast = (fast->next)->next;  
21.         if (low == fast)  
22.         {  
23.             return true;  
24.         }  
25.     }  
26.     return false;  
27. }  
28.    
29. // 2) 查找环的入口  
30. template<typename T>  
31. T* findLoopPort(T* head)  
32. {  
33.     // 判断是否有环，五环返回NULL  
34.     if (!checkCircle(head))  
35.         return NULL;  
36.     T* low = head;  
37.     T* fast = head;  
38.     // low按照步长1增加，fast按照步长2增加，找到碰撞点  
39.     while (1)  
40.     {  
41.         low = low->next;  
42.         fast = fast->next->next;  
43.         if (low == fast)  
44.             break;  
45.     }  
46.    
47.     // 分别从头结点和碰撞节点开始按照步长1增加，遍历链表，第一个节点相同的点是环入口点  
48.     low = head;  
49.     while (low != fast)  
50.     {  
51.         low = low->next;  
52.         fast = fast->next;  
53.     }  
54.     return low;   
55. }  
56.    
57. // 3) 计算环的长度  
58. template<typename T>  
59. int getLoopLength(T* head)  
60. {  
61.     if (!checkCircle(head))  
62.         return 0;  
63.    
64.     T* low = head;  
65.     T* fast = head;  
66.     int length = 0;  
67.     // low按照步长1增加，fast按照步长2增加，找到碰撞点,然后接着循环直到下一次碰撞，  
68.     // 计算两次碰撞之间的循环次数即为长度  
69.     while (1)  
70.     {  
71.         low = low->next;  
72.         fast = fast->next->next;  
73.         if (low == fast)  
74.             break;  
75.     }  
76.     while(1)  
77.     {  
78.         low = low->next;  
79.         fast = fast->next->next;  
80.         length++;  
81.         if (low == fast)  
82.             break;  
83.     }  
84.     return length;  
85. }  
86.    
87. // 4) 计算有环链表的尾长度  
88. template<typename T>  
89. int getTailLength(T* head)  
90. {  
91.     T* port = findLoopPort(head);  
92.     int length = 0;  
93.     T* temp = head;  
94.     while (temp != port)  
95.     {  
96.         length++;  
97.         temp = temp->next;  
98.     }  
99.     return length;  
100. }  
101.    
102. // 5) 判断两个链表是否相交  
103. template<typename T>  
104. bool isListJunction(T* head1, T* head2)  
105. {  
106.     if (NULL == head1 || NULL == head2)  
107.     {  
108.         return false;  
109.     }  
110.     // 如果头结点相同，代表相同的链表，肯定是相交  
111.     if (head1 == head2)  
112.     {  
113.         return true;  
114.     }  
115.    
116.     // 检测是否有环  
117.     bool b1 = checkCircle(head1);  
118.     bool b2 = checkCircle(head2);  
119.     // 若相交，则两个链表要么都无环，要么都有环  
120.     if (b1 != b2)  
121.     {  
122.         return false;  
123.     }  
124.    
125.     // 若都无环，b1==b2==0,尾节点必然相同，是Y字形  
126.     if (!b1)  
127.     {  
128.         while (head1->next != NULL)  
129.         {  
130.             head1 = head1->next;  
131.         }  
132.         while (head2->next != NULL)  
133.         {  
134.             head2 = head2->next;  
135.         }  
136.         if (head1 == head2)  
137.         {  
138.             return true;  
139.         }  
140.     }  
141.     // 若有环，则找出链表1的环入口，看是否在链表2上  
142.     if (b1)  
143.     {  
144.         T* port = findLoopPort(head1);  
145.         if (port != NULL)  
146.         {  
147.             T* temp = head2;  
148.             int length2 = getLoopLength(head2) + getTailLength(head2);  
149.             while (port != temp && (length2--) >= 0)  
150.                 temp = temp->next;  
151.             if (port == temp)  
152.                 return true;  
153.             else  
154.                 return false;  
155.         }  
156.     }  
157.    
158.     return false;  
159. }  
160.    
161. // 6) 判断两个链表是否相交，并输出相交节点  
162. template<typename T>  
163. bool isListJunction(T* head1, T* head2, T *&junctionNode)  
164. {  
165.     if (NULL == head1 || NULL == head2)  
166.     {  
167.         return false;  
168.     }  
169.     // 如果头结点相同，代表相同的链表，肯定是相交  
170.     if (head1 == head2)  
171.     {  
172.         junctionNode = head1;  
173.         return true;  
174.     }  
175.    
176.     // 检测是否有环  
177.     bool b1 = checkCircle(head1);  
178.     bool b2 = checkCircle(head2);  
179.     // 若相交，则两个链表要么都无环，要么都有环  
180.     if (b1 != b2)  
181.     {  
182.         return false;  
183.     }  
184.    
185.     // 若都无环，b1==b2==0,尾节点必然相同，是Y字形  
186.     if (!b1)  
187.     {  
188.         T* node1 = head1;  
189.         T* node2 = head2;  
190.         while (node1->next != NULL)  
191.         {  
192.             node1 = node1->next;  
193.         }  
194.         while (node2->next != NULL)  
195.         {  
196.             node2 = node2->next;  
197.         }  
198.         if (node1 == node2)  
199.         {  
200.             // 相交，把第一个链表的尾节点指向第二个链表  
201.             node1->next = head2;  
202.             junctionNode = findLoopPort(head1);  
203.             return true;  
204.         }  
205.     }  
206.     // 若有环，则找出链表1的环入口，看是否在链表2上  
207.     if (b1)  
208.     {  
209.         int length1 = getLoopLength(head1) + getTailLength(head1);  
210.         int length2 = getLoopLength(head2) + getTailLength(head2);  
211.         int len = length2;  
212.         T* port = findLoopPort(head1);  
213.         if (port != NULL)  
214.         {  
215.             T* temp = head2;  
216.             while (port != temp && (len--) >= 0)  
217.                 temp = temp->next;  
218.             if (port == temp)  
219.             {  
220.                 // 若长度相等，同步寻找相同的节点  
221.                 if (length1 == length2)  
222.                 {  
223.                     while (head1 != head2)  
224.                     {  
225.                         head1 = head1->next;  
226.                         head2 = head2->next;  
227.                     }  
228.                     junctionNode = head1;  
229.                 }  
230.                 // 若长度不等，长的先剪掉长度差，然后再同步递增  
231.                 else if (length1 > length2)  
232.                 {  
233.                     int step = length1 - length2;  
234.                     while (step--)  
235.                     {  
236.                         head1 = head1->next;  
237.                     }  
238.                     while (head1 != head2)  
239.                     {  
240.                         head1 = head1->next;  
241.                         head2 = head2->next;  
242.                     }  
243.                     junctionNode = head1;  
244.                 }  
245.                 else  
246.                 {  
247.                     int step = length2 - length1;  
248.                     while (step--)  
249.                     {  
250.                         head2 = head2->next;  
251.                     }  
252.                     while (head1 != head2)  
253.                     {  
254.                         head1 = head1->next;  
255.                         head2 = head2->next;  
256.                     }  
257.                     junctionNode = head1;  
258.                 }  
259.                 return true;  
260.             }  
261.             else  
262.             {  
263.                 return false;  
264.             }  
265.         }  
266.     }  
267.    
268.     return false;  
269. }  
270.    
271. template <typename T>  
272. struct listNode  
273. {  
274.     T val;  
275.     listNode *pre;  
276.     listNode *next;  
277.     listNode()  
278.     {  
279.         pre = NULL;  
280.         next = NULL;  
281.     }  
282.     listNode(T value)  
283.     {  
284.         val = value;  
285.         pre = NULL;  
286.         next = NULL;  
287.     }  
288. };  
289. int main(int argc,char** argv)  
290. {  
291.     string first = "my is";  
292.     string second = "your";  
293.     string three = "is";  
294.     string four = "king";  
295.     string five = "name";  
296.     string first2 = "speak";  
297.     string second2 = "what";  
298.     list<string> firstlist;  
299.     firstlist.push_back(first);  
300.     firstlist.push_back(second);  
301.     firstlist.push_back(three);  
302.     firstlist.push_back(four);  
303.     firstlist.push_back(five);  
304.     list<string> secondlist;  
305.     secondlist.push_back(first2);  
306.     secondlist.push_back(second2);  
307.     secondlist.push_back(four);  
308.     secondlist.push_back(five);  
309.     // 链表1，无环  
310.     listNode<string> *head1 = new listNode<string>(first);  
311.     listNode<string> *pnode2 = new listNode<string>(second);  
312.     head1->next = pnode2;  
313.     listNode<string> *pnode3 = new listNode<string>(three);  
314.     pnode2->next = pnode3;  
315.     listNode<string> *pnode4 = new listNode<string>(four);  
316.     pnode3->next = pnode4;  
317.     listNode<string> *pnode5 = new listNode<string>(five);  
318.     pnode4->next = pnode5;  
319.     // 链表2，无环  
320.     listNode<string> *head2 = new listNode<string>(first2);  
321.     listNode<string> *pnode22 = new listNode<string>(second2);  
322.     head2->next = pnode22;  
323.     pnode22->next = pnode4;  
324.     pnode4->next = pnode5;  
325.     // 链表1、2相交  
326.     bool bJunction = isListJunction(head1,head2);  
327.     std::cout<< bJunction<<std::endl;  
328.     std::cout<< checkCircle(head1)<<endl;  
329.     std::cout<< checkCircle(head2)<<endl;  
330.    
331.     string first3 = "1";  
332.     string second3 = "2";  
333.     string three3 = "3";  
334.     string four3 = "4";  
335.     string five3 = "5";  
336.     string six3 = "6";  
337.     string seven3 = "7";  
338.     // 链表3，有环  
339.     listNode<string> *head3 = new listNode<string>(first3);  
340.     listNode<string> *pnode32 = new listNode<string>(second3);  
341.     head3->next = pnode32;  
342.     listNode<string> *pnode33 = new listNode<string>(three3);  
343.     pnode32->next = pnode33;  
344.     listNode<string> *pnode34 = new listNode<string>(four3);  
345.     pnode33->next = pnode34;  
346.     listNode<string> *pnode35 = new listNode<string>(five3);  
347.     pnode34->next = pnode35;  
348.     listNode<string> *pnode36 = new listNode<string>(six3);  
349.     pnode35->next = pnode36;  
350.     pnode36->next = pnode33;  
351.     cout<<findLoopPort(head3)->val<<endl;  
352.     cout<<getLoopLength(head3)<<endl;  
353.     // 链表4，有环  
354.     listNode<string> *head4 = new listNode<string>(seven3);  
355.     head4->next = pnode32;  
356.     cout<<isListJunction(head3,head4)<<endl;  
357.     cout<< "the length of list3 : "<<getLoopLength(head3) + getTailLength(head3)<<endl;  
358.     cout<< "the length of list4 : "<<getLoopLength(head4) + getTailLength(head3)<<endl;  
359.    
360.     listNode<string> *junctionNode = new listNode<string>;  
361.     cout<<isListJunction(head3,head4,junctionNode)<<endl;  
362.     cout<<"list3 与 list4的交点： "<<junctionNode->val<<endl;  
363.     system("pause");  
364.     return 0;  
365. }