判断两链表是否相交

来源http://blog.csdn.net/huangxy10/article/details/8014233

只介绍O（n）算法

思路1：

将链表1中各结点地址存入HashTable中，

再遍历链表2，如果有结点已经在HashTable中，则两链表相交。

思路2：

将链表1的尾结点和链表2的首结点（注意不是头结点）相连。

再判断是否有环，如果有则两链表相交。

思路3：(最简单的方法）

判断两链表的尾结点是否为同一结点，若是，则相交。

 

实现部分为思路2。

[cpp]  view plain copy print ?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。  
2. //  
3.   
4. #include "stdafx.h"  
5. #include <iostream>  
6. #include <string>  
7. using namespace std;  
8.   
9. //链表的结构体  
10. struct node  
11. {  
12.     char val;  
13.     node * next;  
14. };  
15.   
16. //建立链表  
17. struct node * create( string & str_link )  
18. {  
19.     int len = str_link.length();  
20.   
21.     struct node * phead = new node();     //带有表头的链表，表头中不存储任何元素  
22.     struct node * preNode = phead;  
23.     for( int i=0; i<len; i++ )  
24.     {  
25.         struct node * pNode = new node();  
26.         pNode->val = str_link[i];  
27.         pNode->next = NULL;  
28.         preNode->next = pNode;  
29.         preNode = pNode;  
30.     }  
31.     return phead;  
32. }  
33.   
34. //输出链表  
35. void out_link( struct node * phead )  
36. {  
37.     if( phead == NULL )  
38.         return;  
39.     struct node * pNode = phead->next;  
40.     while( pNode )  
41.     {  
42.         cout <<pNode->val;  
43.         pNode = pNode->next;  
44.     }  
45.     cout << endl;  
46. }  
47.   
48. //找到第index个元素  
49. struct node * find_node(struct node* phead, int index )  
50. {  
51.     if(!phead) return NULL;  
52.     struct node * pNode = phead;  
53.     while( index--)  
54.     {  
55.         pNode = pNode->next;  
56.         if( !pNode )  
57.             return NULL;  
58.     }  
59.     return pNode;  
60. }  
61.   
62. //检查链表有无环  
63. //有，则返回快慢指针共同指向的点  
64. //无，则返回空指针  
65. struct node * check_loop( struct node * phead )  
66. {  
67.     if(!phead)  
68.          return NULL;  
69.     struct node * pFast = phead;  
70.     struct node * pSlow = phead;  
71.   
72.     int step = 1;  
73.     while( pFast )  
74.     {  
75.         pFast = pFast->next;  
76.         if( step++%2==0 )  
77.         {  
78.             pSlow = pSlow->next;  
79.             if( pSlow == pFast )  
80.                 return pSlow;  
81.         }  
82.     }  
83.     return NULL;  
84. }  
85.   
86. //求两个节点的距离，即中间有多少个连线  
87. //返回-1为出错，如果是同一节点，则返回0  
88. int find_length( struct node* pNode1, struct node* pNode2 )  
89. {  
90.     if(!pNode1||!pNode2) return -1;  
91.   
92.     int len=0;  
93.     while( pNode1 )  
94.     {  
95.         if( pNode1 == pNode2 )  
96.             return len;  
97.         pNode1 = pNode1->next;  
98.         len++;  
99.     }  
100.     return -1;  
101. }  
102.   
103. //找环的起始点,pTail为快慢指针共同指向的节点  
104. struct node * loop_first_node( struct node * phead, struct node * pTail )  
105. {  
106.     if( !phead || !pTail ) return NULL;  
107.     struct node * pNode1 = pTail->next;  
108.     struct node * pNode2 = phead->next;  
109.     int M = find_length( pNode1, pTail );  
110.     int N = find_length( pNode2, pTail );  
111.   
112.     if( M > N )  
113.     {  
114.         int step = M-N;  
115.         while(step--)  
116.             pNode1 = pNode1->next;  
117.     }  
118.     if( N > M )  
119.     {  
120.         int step = N-M;  
121.         while(step--)  
122.             pNode2 = pNode2->next;  
123.     }  
124.     while(pNode1&&pNode2)  
125.     {  
126.         if(pNode1 == pNode2 )  
127.             return pNode1;  
128.         pNode1 = pNode1->next;  
129.         pNode2 = pNode2->next;  
130.     }  
131.     return NULL;  
132. }  
133.   
134. void test()  
135. {  
136.     string str;  
137.     cin >> str;  
138.     struct node *phead1 = create( str );  
139.       
140.     int index;  
141.     cin >> index;  
142.     struct node * pNode1 = find_node( phead1, index );  
143.   
144.     cin >> str;  
145.     struct node *phead2 = create( str );  
146.   
147.     struct node * pNode = phead2;  
148.     while( pNode->next )  
149.         pNode = pNode->next;  
150.     pNode->next = pNode1;        //生成相交链表, 注释掉之一行则为不相交  
151.   
152.     while( pNode->next )           //找到链表1的尾结点  
153.         pNode = pNode->next;  
154.     pNode->next = phead2->next;    //连接链表2的首结点  
155.     struct node * pTail = check_loop( phead1 ); //检查是否有环  
156.     struct node * pFirstLoopNode = NULL;  
157.     if( pTail )  
158.     {     
159.         cout <<"cross." <<endl;  
160.     }  
161.     else  
162.         cout << "no cross." <<endl;  
163.   
164. }  
165.   
166. int _tmain(int argc, _TCHAR* argv[])  
167. {  
168.     test();  
169.     return 0;  
170. }