链表

单链表

目录

1.单链表反转

2.找出单链表的倒数第4个元素

3.找出单链表的中间元素

4.删除无头单链表的一个节点

5.两个不交叉的有序链表的合并

6.有个二级单链表，其中每个元素都含有一个指向一个单链表的指针。

写程序把这个二级链表称一级单链表。

7.单链表交换任意两个元素（不包括表头）

8.判断单链表是否有环？如何找到环的“起始”点？如何知道环的长度？

9.判断两个单链表是否相交

10.两个单链表相交，计算相交点

11.用链表模拟大整数加法运算

12.单链表排序

13.删除单链表中重复的元素

这些题目在面试中经常出现，所以在这个专题中总结一下，

我所使用的代码都是C/C++。

会写一些思路，这样就不必看代码了。

冰冻三尺，非一日之寒，让我们慢慢来练习吧。

链表的节点定义如下：

[cpp] view plaincopyprint?

1. struct node
2. {
3. char val;
4. node * next;
5. };

struct node{char val;node * next;};

用结构体定义，而不是用类。

从使用的方便来说，类要更好一些，

但是为了和其他关于链表的地方保持一致还是使用了结构体来定义。

节点元素为char型，是为了输出和调试方便。

注：这些题目都是前人总结的。

总结：

1，使用指针时，一定要检查指针是否为空；

2，要考虑特殊情况，如指针为空，空链表（只有表头结点），只有一个结点等；

3，插入，删除，交换等操作时都需要使用当前结点的前驱，需要同时记录下来；

4，单链表有无环以及交叉链表求相交结点的两个题目有很大的联系，

也是经常考的题目，有些题目可以转化成这类题目；

5，递归思想很重要，在链表的倒序输出，反转，模拟大数相交，

快速排序中都有用到，分治算法往往需要用递归来做；

6，快慢指针的思想很重要，常数时间删除结点的算法也很考察智力。

 

题目：

顾名思义，就是反转一个单链表。

思路1：

重新开辟内存，简历一个新链表，然后从后面往前面复制。

由于单链表无法很容易得到当前节点前面的节点，所以，复制每一个节点都得从前往后找到该节点，

单个节点复制的时间复杂度为O(n)，整个复杂度则为O（n^2)，空间复杂度为O（n）。不可取。

思路2：

不开辟新内存，采用交换节点内容的方式。

前后两个指针，相互交换内容，之后前面的指针后移，后面的指针前移，再交换。

问题是后面指针前移的时间复杂度依然是O（n），所以时间复制度不变，仍为O（n^2）。不可取。

思路3,：

改变指针指向。时间复杂度为O（n），空间复杂度为O(1）。

注意：

输入可能为：

1，NULL

2，空链表，即只含有表头结点

3，单一结点，只有一个有效结点

4，多个结点

前三种情况都不需要处理。

反转当前结点pNode时，需要记录下一个结点pNext，且需要当前结点的上一个结点preNode。

第一个结点的反转比较特殊，初始化这些指针即可，且将第一结点的next置NULL。

结束之后，所有结点处理完了。加上表头结点即可。

注意：

有表头结点。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //1.单链表反转
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
34. void out_link( struct node * phead )
35. {
36. if( phead == NULL )
37. return;
38. struct node * pNode = phead->next;
39. while( pNode )
40. {
41. cout <<pNode->val;
42. pNode = pNode->next;
43. }
44. cout << endl;
45. }
47. void reverse_link(struct node * phead )
48. {
49. if( !phead || !phead->next || !phead->next->next )//无链表，空链表，当个节点链表则返回
50. return;
52. //处理第一个节点
53. struct node * preNode = phead->next;
54. struct node * pNode = preNode->next;
55. preNode->next = NULL;
57. //从第二个节点开始处理
58. while(pNode)
59. {
60. struct node * pNext = pNode->next;
61. pNode->next = preNode;
62. preNode = pNode;
63. pNode = pNext;
64. }
66. //加上表头节点
67. phead->next = preNode;
68. }
70. void reverse_test()
71. {
72. string str;
73. cin >> str;
74. struct node *phead = create( str );
75. out_link( phead );
76. reverse_link( phead );
77. out_link( phead );
78. }
80. int _tmain(int argc, _TCHAR* argv[])
81. {
82. reverse_test();
83. return 0;
84. }

// LinkTable.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include <iostream>#include <string>using namespace std;//链表的结构体struct node{char val;node * next;};//1.单链表反转struct node * create( string & str_link ){int len = str_link.length();struct node * phead = new node();     //带有表头的链表，表头中不存储任何元素struct node * preNode = phead;for( int i=0; i<len; i++ ){struct node * pNode = new node();pNode->val = str_link[i];pNode->next = NULL;preNode->next = pNode;preNode = pNode;}return phead;}void out_link( struct node * phead ){if( phead == NULL )return;struct node * pNode = phead->next;while( pNode ){cout <<pNode->val;pNode = pNode->next;}cout << endl;}void reverse_link( struct node * phead ){if( !phead || !phead->next || !phead->next->next ) //无链表，空链表，当个节点链表则返回return;//处理第一个节点struct node * preNode = phead->next;struct node * pNode = preNode->next;preNode->next = NULL;//从第二个节点开始处理while(pNode){struct node * pNext = pNode->next;pNode->next = preNode;preNode = pNode;pNode = pNext;}//加上表头节点phead->next = preNode;}void reverse_test(){string str;cin >> str;struct node *phead = create( str );out_link( phead );reverse_link( phead );out_link( phead );}int _tmain(int argc, _TCHAR* argv[]){reverse_test();return 0;}

 

注意：

无论采用什么思路，编程时都要考虑，链表结点个数不足4个的情况。

思路1：

先找到最后一个元素，然后再从头扫描一遍，判断该元素的之后的第三个结点是否是最后一个结点。O（4n）=O（n）。比较粗糙的方法。

思路2：

快慢指针。先让快指针先走4步，找到第四个结点。然后让快慢指针同时走，每次一步。当快指针走到最后一个结点时，慢指针指向倒数第4个元素。

思路3：

建立一个含有4个元素的循环队列（数组来模拟），扫描一遍队列，让他们不断的进入循环队列中，当最后一个结点进入循环队列后，队列的下一个元素则是倒数第4个结点。

我采用思路2来实现。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //2，找第4个结点
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
34. void out_link( struct node * phead )
35. {
36. if( phead == NULL )
37. return;
38. struct node * pNode = phead->next;
39. while( pNode )
40. {
41. cout <<pNode->val;
42. pNode = pNode->next;
43. }
44. cout << endl;
45. }
47. struct node * find_third_node(struct node * phead )
48. {
49. if( !phead ) return NULL;
51. //快指针先走4步
52. struct node *pFast = phead;
53. struct node *pSlow = phead;
54. int num =4;
55. while(num--)
56. {
57. pFast = pFast->next;
58. if(!pFast) //还没走完就没了
59. {
60. return NULL;
61. break;
62. }
63. }
65. //快慢指针一起走
66. while(pFast)
67. {
68. pFast = pFast->next;
69. pSlow = pSlow->next;
70. }
72. return pSlow;
75. }
77. void test()
78. {
79. string str;
80. cin >> str;
81. struct node *phead = create( str );
82. cout << "The Link is : ";
83. out_link( phead );
84. struct node *pNode = find_third_node( phead );
85. if( pNode )
86. cout << "The last_third node's value is : " << pNode->val <<endl;
87. else
88. cout << "The number of node is less than 4." << endl;
89. }
91. int _tmain(int argc, _TCHAR* argv[])
92. {
93. test();
94. return 0;
95. }

问题：

找出单链表的中间元素

思路：

快慢指针。

快指针每次走两步，慢指针每次走1步。快指针走到头时，慢指针所指即为中间结点。

如果结点个数N为偶数，则中间结点为第N/2个结点。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //2，找第4个结点
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
34. void out_link( struct node * phead )
35. {
36. if( phead == NULL )
37. return;
38. struct node * pNode = phead->next;
39. while( pNode )
40. {
41. cout <<pNode->val;
42. pNode = pNode->next;
43. }
44. cout << endl;
45. }
47. struct node * find_mid_node(struct node * phead )
48. {
49. if( !phead ) return NULL;
51. //快慢指针
52. struct node *pFast = phead;
53. struct node *pSlow = phead;
55. int count = 1;
56. while(pFast)
57. {
58. pFast = pFast->next;
59. if( (count++)%2 ==0 )
60. pSlow = pSlow->next;
61. }
63. return pSlow;
64. }
66. void test()
67. {
68. string str;
69. cin >> str;
70. struct node *phead = create( str );
71. cout << "The Link is : ";
72. out_link( phead );
73. struct node *pNode = find_mid_node( phead );
74. if( pNode )
75. cout << "The mid node's value is : " << pNode->val <<endl;
77. }
79. int _tmain(int argc, _TCHAR* argv[])
80. {
81. test();
82. return 0;
83. }

// LinkTable.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include <iostream>#include <string>using namespace std;//链表的结构体struct node{char val;node * next;};//2，找第4个结点struct node * create( string & str_link ){int len = str_link.length();struct node * phead = new node();     //带有表头的链表，表头中不存储任何元素struct node * preNode = phead;for( int i=0; i<len; i++ ){struct node * pNode = new node();pNode->val = str_link[i];pNode->next = NULL;preNode->next = pNode;preNode = pNode;}return phead;}void out_link( struct node * phead ){if( phead == NULL )return;struct node * pNode = phead->next;while( pNode ){cout <<pNode->val;pNode = pNode->next;}cout << endl;}struct node * find_mid_node( struct node * phead ){if( !phead ) return NULL;//快慢指针struct node *pFast = phead;struct node *pSlow = phead;int count = 1;while(pFast){pFast = pFast->next;if( (count++)%2 ==0 )pSlow = pSlow->next;}return pSlow;}void test(){string str;cin >> str;struct node *phead = create( str );cout << "The Link is : ";out_link( phead );struct node *pNode = find_mid_node( phead );if( pNode )cout << "The mid node's value is : " << pNode->val <<endl;}int _tmain(int argc, _TCHAR* argv[]){test();return 0;}

 

问题：

一个单链表，很长，遍历一遍很慢，我们仅知道一个指向某节点的指针pNode，而我们又想删除这个节点。

思路：

将该结点的下一个结点的内容拷贝到当前结点，然后删除下一个结点。

如果该结点时最后一个结点，则必须遍历一遍单链表，找到前面一个结点，然后删掉该结点。

 

注意：

虽然最后一种情况是线性复杂度的，但是总体上来看还是常数时间的。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //2，找第4个结点
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
34. void out_link( struct node * phead )
35. {
36. if( phead == NULL )
37. return;
38. struct node * pNode = phead->next;
39. while( pNode )
40. {
41. cout <<pNode->val;
42. pNode = pNode->next;
43. }
44. cout << endl;
45. }
47. struct node * find_third_node(struct node * phead )
48. {
49. if( !phead ) return NULL;
51. //快指针先走4步
52. struct node *pFast = phead;
53. struct node *pSlow = phead;
54. int num =4;
55. while(num--)
56. {
57. pFast = pFast->next;
58. if(!pFast) //还没走完就没了
59. {
60. return NULL;
61. break;
62. }
63. }
65. //快慢指针一起走
66. while(pFast)
67. {
68. pFast = pFast->next;
69. pSlow = pSlow->next;
70. }
72. return pSlow;
73. }
75. struct node * find_last_node(struct node * phead )
76. {
77. struct node *pNode = phead;
78. while(pNode->next)
79. {
80. pNode = pNode->next;
81. }
82. return pNode;
83. }
85. void delete_node(struct node * phead, struct node * pNode )
86. {
87. if( !phead ) return;
89. //如果pNode是最后一个结点，则找到前面一个结点
90. if( !pNode->next )
91. {
92. struct node *preNode = phead;
93. while(phead)
94. {
95. if(preNode->next==pNode)
96. break;
97. else
98. preNode = preNode->next;
99. }
100. if( !preNode )
101. {
102. cout <<"The node is not in the link list" << endl;
103. return;
104. }
105. preNode->next = NULL;
106. delete pNode;
107. }
108. else //否则拷贝下一个元素的内容，并删除下一个结点
109. {
110. struct node * pNext = pNode->next;
111. pNode->val = pNext->val;
112. pNode->next = pNext->next;
113. delete pNext;
114. }
115. }
117. void test()
118. {
119. string str;
120. cin >> str;
121. struct node *phead = create( str );
122. cout << "The Link is : ";
123. out_link( phead );
124. struct node *pNode = find_third_node(phead);
126. delete_node( phead, pNode );
127. cout << "delete the last third node:" <<endl;
128. out_link( phead );
129. pNode = find_last_node(phead);
130. delete_node( phead, pNode );
131. cout << "delete last node: "<<endl;
132. out_link( phead );
134. }
136. int _tmain(int argc, _TCHAR* argv[])
137. {
138. test();
139. return 0;
140. }

思路：

比较大小，控制指针指向，如果一个链表已经结束，则把剩下的链表加上去即可。

注意：

要判断输入时候正确。

两个链表是否为空链表等特殊情况。

如果交叉了怎么办。后面会介绍。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //2，找第4个结点
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
34. void out_link( struct node * phead )
35. {
36. if( phead == NULL )
37. return;
38. struct node * pNode = phead->next;
39. while( pNode )
40. {
41. cout <<pNode->val;
42. pNode = pNode->next;
43. }
44. cout << endl;
45. }
48. struct node * merge_link( struct node * phead1, struct node * phead2 )
49. {
50. if( !phead1 || !phead1->next)return phead2;
51. if( !phead2 || !phead2->next)return phead1;
53. struct node * phead = phead1;
54. struct node * pNode = phead;
55. struct node * pNode1 = phead1->next;
56. struct node * pNode2 = phead2->next;
57. delete phead2;
59. while( pNode1 && pNode2)
60. {
61. if( pNode1->val <= pNode2->val )
62. {
63. pNode->next = pNode1;
64. pNode1 = pNode1->next;
65. }
66. else
67. {
68. pNode->next = pNode2;
69. pNode2 = pNode2->next;
70. }
71. pNode = pNode->next;
72. }
74. if( pNode2 )
75. pNode->next = pNode2;
77. if( pNode1 )
78. pNode->next = pNode1;
80. return phead;
81. }
83. void test()
84. {
85. string str;
86. cin >> str;
87. struct node *phead1 = create( str );
88. cin >> str;
89. struct node *phead2 = create( str );
91. struct node * phead = merge_link( phead1, phead2 );
92. cout << "after merge: "<<endl;
93. out_link( phead );
95. }
97. int _tmain(int argc, _TCHAR* argv[])
98. {
99. test();
100. return 0;
101. }

思路：

有两种情况，相邻和不相邻。

首先找两个节点的前驱，可以通过前驱来判断是否相邻。

相邻则改变3个结点的next指针，不相邻则改变4个结点的next指针。

注意：

要判断许多出错的情况，比如，结点不在表中，结点为空，表为空等。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //建立链表
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
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. }
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. }
62. //找前驱节点
63. struct node* find_preNode(struct node* phead, struct node* pNode)
64. {
65. if( !pNode ) return NULL;
66. struct node* preNode = phead;
67. while( preNode )
68. {
69. if( preNode->next == pNode )
70. return preNode;
71. preNode = preNode->next;
72. }
73. return NULL;
74. }
76. //交换节点
77. void exchange_node(struct node* phead, struct node* pNode1,struct node* pNode2)
78. {
79. if( !phead ) return;
80. //分别找到pNode1的前驱pPre1,和pNode2的前驱pPre2
81. struct node* pPre1 = find_preNode( phead, pNode1);
82. struct node* pPre2 = find_preNode( phead, pNode2);
83. if( !pPre1 || !pPre2 )return; //有任何一个没有找到
85. //相邻的情况
86. struct node *pBefore, *pAfter, *pPre;
87. if( pPre2 == pNode1 )
88. {
89. pBefore = pNode1;
90. pAfter = pNode2;
91. pPre = pPre1;
92. }
93. if( pPre1 == pNode2)
94. {
95. pBefore = pNode2;
96. pAfter = pNode1;
97. pPre = pPre2;
98. }
99. if( pPre2 == pNode1 || pPre1 == pNode2 )
100. {
101. pPre->next = pAfter;
102. pBefore->next = pAfter->next;
103. pAfter->next = pBefore;
104. }
105. else
106. {
107. //不相邻的情况
108. struct node *pNext1 = pNode1->next;
109. pNode1->next = pNode2->next;
110. pPre1->next = pNode2;
111. pPre2->next = pNode1;
112. pNode2->next = pNext1;
113. }
115. }
117. void test()
118. {
119. string str;
120. cin >> str;
121. struct node *phead = create( str );
123. int index;
124. cin >> index;
125. struct node * pNode1 = find_node( phead, index );
126. cin >> index;
127. struct node * pNode2 = find_node( phead, index );
128. exchange_node( phead, pNode1, pNode2 );
129. cout << "after exchange: "<<endl;
130. out_link( phead );
132. }
134. int _tmain(int argc, _TCHAR* argv[])
135. {
136. test();
137. return 0;
138. }

// LinkTable.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include <iostream>#include <string>using namespace std;//链表的结构体struct node{char val;node * next;};//建立链表struct node * create( string & str_link ){int len = str_link.length();struct node * phead = new node();     //带有表头的链表，表头中不存储任何元素struct node * preNode = phead;for( int i=0; i<len; i++ ){struct node * pNode = new node();pNode->val = str_link[i];pNode->next = NULL;preNode->next = pNode;preNode = pNode;}return phead;}//输出链表void out_link( struct node * phead ){if( phead == NULL )return;struct node * pNode = phead->next;while( pNode ){cout <<pNode->val;pNode = pNode->next;}cout << endl;}//找到第index个元素struct node * find_node(struct node* phead, int index ){if(!phead) return NULL;struct node * pNode = phead;while( index--){pNode = pNode->next;if( !pNode )return NULL;}return pNode;}//找前驱节点struct node* find_preNode( struct node* phead, struct node* pNode){if( !pNode ) return NULL;struct node* preNode = phead;while( preNode ){if( preNode->next == pNode )return preNode;preNode = preNode->next;}return NULL;}//交换节点void exchange_node( struct node* phead, struct node* pNode1, struct node* pNode2){if( !phead ) return;//分别找到pNode1的前驱pPre1,和pNode2的前驱pPre2struct node* pPre1 = find_preNode( phead, pNode1);struct node* pPre2 = find_preNode( phead, pNode2);if( !pPre1 || !pPre2 ) return;  //有任何一个没有找到//相邻的情况struct node *pBefore, *pAfter, *pPre;if( pPre2 == pNode1 ){pBefore = pNode1;pAfter = pNode2;pPre = pPre1;}if( pPre1 == pNode2){pBefore = pNode2;pAfter = pNode1;pPre = pPre2;}if( pPre2 == pNode1 || pPre1 == pNode2 ){pPre->next = pAfter;pBefore->next = pAfter->next;pAfter->next = pBefore;}else{//不相邻的情况struct node *pNext1 = pNode1->next;pNode1->next = pNode2->next;pPre1->next = pNode2;pPre2->next = pNode1;pNode2->next = pNext1;}}void test(){string str;cin >> str;struct node *phead = create( str );int index;cin >> index;struct node * pNode1 = find_node( phead, index );cin >> index;struct node * pNode2 = find_node( phead, index );exchange_node( phead, pNode1, pNode2 );cout << "after exchange: "<<endl;out_link( phead );}int _tmain(int argc, _TCHAR* argv[]){test();return 0;}

判断单链表是否有环？

思路：

快慢指针，快指针每次走两步，慢指针每次走一步。

每次判断快指针是否到头了以及快慢指针是否指向同一元素。

快指针走到头了，则没有环；

如果快指针和慢指针指向同一个元素，则有环。

如何找到环的起始点？

思路：

如果有环，则快慢指针一定相遇在环上。

将环从快慢指针相遇结点剪开，则变成了两个单链表相交的问题。

设两个单链表的长度分别为N，M，用两个指针分别指向两链表第一个结点，

让位于长链表上的指针先走abs（N-M）步。然后一起走，相遇时则为环的起始点。

如何知道环的长度？

绕一圈即可。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //建立链表
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
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. }
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. }
64. //检查链表有无环
65. //有，则返回快慢指针共同指向的点
66. //无，则返回空指针
67. struct node * check_loop(struct node * phead )
68. {
69. if(!phead)
70. return NULL;
71. struct node * pFast = phead;
72. struct node * pSlow = phead;
74. int step = 1;
75. while( pFast )
76. {
77. pFast = pFast->next;
78. if( step++%2==0 )
79. {
80. pSlow = pSlow->next;
81. if( pSlow == pFast )
82. return pSlow;
83. }
84. }
85. return NULL;
86. }
88. //求两个节点的距离，即中间有多少个连线
89. //返回-1为出错，如果是同一节点，则返回0
90. int find_length( struct node* pNode1,struct node* pNode2 )
91. {
92. if(!pNode1||!pNode2) return -1;
94. int len=0;
95. while( pNode1 )
96. {
97. if( pNode1 == pNode2 )
98. return len;
99. pNode1 = pNode1->next;
100. len++;
101. }
102. return -1;
103. }
105. //找环的起始点,pTail为快慢指针共同指向的节点
106. struct node * loop_first_node(struct node * phead, struct node * pTail )
107. {
108. if( !phead || !pTail ) return NULL;
109. struct node * pNode1 = pTail->next;
110. struct node * pNode2 = phead->next;
111. int M = find_length( pNode1, pTail );
112. int N = find_length( pNode2, pTail );
114. if( M > N )
115. {
116. int step = M-N;
117. while(step--)
118. pNode1 = pNode1->next;
119. }
120. if( N > M )
121. {
122. int step = N-M;
123. while(step--)
124. pNode2 = pNode2->next;
125. }
126. while(pNode1&&pNode2)
127. {
128. if(pNode1 == pNode2 )
129. return pNode1;
130. pNode1 = pNode1->next;
131. pNode2 = pNode2->next;
132. }
133. return NULL;
134. }
136. void test()
137. {
138. string str;
139. cin >> str;
140. struct node *phead = create( str );
142. int index;
143. cin >> index;
144. struct node * pNode1 = find_node( phead, index );
145. struct node * pNode = phead;
146. while( pNode->next )
147. pNode = pNode->next;
148. pNode->next = pNode1; //生成有环链表, 注释掉之一行则为无环链表
149. struct node * pTail = check_loop( phead );
150. struct node * pFirstLoopNode = NULL;
151. if( pTail )
152. {
153. cout <<"The link has loop." <<endl;
154. pFirstLoopNode = loop_first_node(phead, pTail);
155. cout <<"First Loop Node is: " << pFirstLoopNode->val <<endl;
156. cout <<"The number of node in loop is: " << find_length( pTail->next, pTail)+1 <<endl;
157. }
158. else
159. cout << "The link table has no loop." <<endl;
161. }
163. int _tmain(int argc, _TCHAR* argv[])
164. {
165. test();
166. return 0;
167. }

只介绍O（n）算法

思路1：

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

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

思路2：

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

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

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

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

实现部分为思路2。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //建立链表
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
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. }
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. }
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;
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. }
86. //求两个节点的距离，即中间有多少个连线
87. //返回-1为出错，如果是同一节点，则返回0
88. int find_length( struct node* pNode1,struct node* pNode2 )
89. {
90. if(!pNode1||!pNode2) return -1;
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. }
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 );
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. }
134. void test()
135. {
136. string str;
137. cin >> str;
138. struct node *phead1 = create( str );
140. int index;
141. cin >> index;
142. struct node * pNode1 = find_node( phead1, index );
144. cin >> str;
145. struct node *phead2 = create( str );
147. struct node * pNode = phead2;
148. while( pNode->next )
149. pNode = pNode->next;
150. pNode->next = pNode1; //生成相交链表, 注释掉之一行则为不相交
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;
164. }
166. int _tmain(int argc, _TCHAR* argv[])
167. {
168. test();
169. return 0;
170. }

分别计算两链表的长度，为M，N。让指向长链表的指针先走，让两链表等长，

再两指针一起走，第一次相遇点即为相交点。

如果把相交链表变成一个环，则环的第一个结点即为相交点。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //建立链表
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
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. }
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. }
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;
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. }
86. //求两个节点的距离，即中间有多少个连线
87. //返回-1为出错，如果是同一节点，则返回0
88. int find_length( struct node* pNode1,struct node* pNode2 )
89. {
90. if(!pNode1||!pNode2) return -1;
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. }
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 );
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. }
134. void test()
135. {
136. string str;
137. cout << "Input the first link:"<<endl;
138. cin >> str;
139. struct node *phead1 = create( str );
141. int index;
142. cout << "Input the index of cross node: " <<endl;
143. cin >> index;
144. struct node * pNode1 = find_node( phead1, index );
145. cout << "Input the second link:"<<endl;
146. cin >> str;
147. struct node *phead2 = create( str );
149. struct node * pNode = phead2;
150. while( pNode->next )
151. pNode = pNode->next;
152. pNode->next = pNode1; //生成相交链表, 注释掉这一行则为不相交
154. while( pNode->next ) //找到链表1的尾结点
155. pNode = pNode->next;
156. pNode->next = phead2->next; //连接链表2的首结点
157. struct node * pTail = check_loop( phead1 );//检查是否有环
158. struct node * pFirstLoopNode = NULL;
159. if( pTail )
160. {
161. cout <<"cross." <<endl;
162. pFirstLoopNode = loop_first_node(phead1, pTail);
163. cout <<"The cross node is: "<< pFirstLoopNode->val << endl;
164. pNode->next = NULL; //还原，把环拆开
165. }
166. else
167. cout << "no cross." <<endl;
169. }
171. int _tmain(int argc, _TCHAR* argv[])
172. {
173. test();
174. return 0;
175. }

// LinkTable.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include <iostream>#include <string>using namespace std;//链表的结构体struct node{char val;node * next;};//建立链表struct node * create( string & str_link ){int len = str_link.length();struct node * phead = new node();     //带有表头的链表，表头中不存储任何元素struct node * preNode = phead;for( int i=0; i<len; i++ ){struct node * pNode = new node();pNode->val = str_link[i];pNode->next = NULL;preNode->next = pNode;preNode = pNode;}return phead;}//输出链表void out_link( struct node * phead ){if( phead == NULL )return;struct node * pNode = phead->next;while( pNode ){cout <<pNode->val;pNode = pNode->next;}cout << endl;}//找到第index个元素struct node * find_node(struct node* phead, int index ){if(!phead) return NULL;struct node * pNode = phead;while( index--){pNode = pNode->next;if( !pNode )return NULL;}return pNode;}//检查链表有无环//有，则返回快慢指针共同指向的点//无，则返回空指针struct node * check_loop( struct node * phead ){if(!phead) return NULL;struct node * pFast = phead;struct node * pSlow = phead;int step = 1;while( pFast ){pFast = pFast->next;if( step++%2==0 ){pSlow = pSlow->next;if( pSlow == pFast )return pSlow;}}return NULL;}//求两个节点的距离，即中间有多少个连线//返回-1为出错，如果是同一节点，则返回0int find_length( struct node* pNode1, struct node* pNode2 ){if(!pNode1||!pNode2) return -1;int len=0;while( pNode1 ){if( pNode1 == pNode2 )return len;pNode1 = pNode1->next;len++;}return -1;}//找环的起始点,pTail为快慢指针共同指向的节点struct node * loop_first_node( struct node * phead, struct node * pTail ){if( !phead || !pTail ) return NULL;struct node * pNode1 = pTail->next;struct node * pNode2 = phead->next;int M = find_length( pNode1, pTail );int N = find_length( pNode2, pTail );if( M > N ){int step = M-N;while(step--)pNode1 = pNode1->next;}if( N > M ){int step = N-M;while(step--)pNode2 = pNode2->next;}while(pNode1&&pNode2){if(pNode1 == pNode2 )return pNode1;pNode1 = pNode1->next;pNode2 = pNode2->next;}return NULL;}void test(){string str;cout << "Input the first link:"<<endl;cin >> str;struct node *phead1 = create( str );int index;cout << "Input the index of cross node: " <<endl;cin >> index;struct node * pNode1 = find_node( phead1, index );cout << "Input the second link:"<<endl;cin >> str;struct node *phead2 = create( str );struct node * pNode = phead2;while( pNode->next )pNode = pNode->next;pNode->next = pNode1;        //生成相交链表, 注释掉这一行则为不相交while( pNode->next )           //找到链表1的尾结点pNode = pNode->next;pNode->next = phead2->next;    //连接链表2的首结点struct node * pTail = check_loop( phead1 ); //检查是否有环struct node * pFirstLoopNode = NULL;if( pTail ){cout <<"cross." <<endl;pFirstLoopNode = loop_first_node(phead1, pTail);cout <<"The cross node is: "<< pFirstLoopNode->val << endl;pNode->next = NULL;            //还原，把环拆开}elsecout << "no cross." <<endl;}int _tmain(int argc, _TCHAR* argv[]){test();return 0;}

 

例如：9->9->9->NULL

+ 1->NULL

1->0->0->0->NULL

思路：

使用递归，能够实现从前往后计算。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //建立链表
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
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. }
48. //求无表头链表的长度
49. //返回-1为链表不存在
50. int link_length( struct node* pNode )
51. {
52. if(!pNode) return -1;
54. int len=0;
55. while( pNode )
56. {
57. pNode = pNode->next;
58. len++;
59. }
60. return len;
61. }
64. //大数相加递归算法
65. //pNode1, pNode2为两个中间运算结点，但不是头结点
66. struct node * add( struct node * pNode1,struct node * pNode2, int & carry )
67. {
68. if( !pNode1 ) return pNode2;
69. if( !pNode2 ) return pNode1;

// LinkTable.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include <iostream>#include <string>using namespace std;//链表的结构体struct node{char val;node * next;};//建立链表struct node * create( string & str_link ){int len = str_link.length();struct node * phead = new node();     //带有表头的链表，表头中不存储任何元素struct node * preNode = phead;for( int i=0; i<len; i++ ){struct node * pNode = new node();pNode->val = str_link[i];pNode->next = NULL;preNode->next = pNode;preNode = pNode;}return phead;}//输出链表void out_link( struct node * phead ){if( phead == NULL )return;struct node * pNode = phead->next;while( pNode ){cout <<pNode->val;pNode = pNode->next;}cout << endl;}//求无表头链表的长度//返回-1为链表不存在int link_length( struct node* pNode ){if(!pNode) return -1;int len=0;while( pNode ){pNode = pNode->next;len++;}return len;}//大数相加递归算法//pNode1, pNode2为两个中间运算结点，但不是头结点struct node * add( struct node * pNode1, struct node * pNode2, int & carry ){if( !pNode1  ) return pNode2;if( !pNode2  ) return pNode1;

[cpp] view plaincopyprint?

1. <SPAN style="WHITE-SPACE: pre"> </SPAN>//为了参数简洁，这里增大了计算量，可以将链表长度作为参数传进来
2. int len1 = link_length( pNode1 );
3. int len2 = link_length( pNode2 );
6. if( len1 == len2 )
7. {
8. if( len1==1 ) //递归终止条件
9. {
10. struct node * pNode = new node();
11. int sum = (pNode1->val -'0' ) + ( pNode2->val -'0');
12. carry = sum/10;
13. pNode->val = sum%10 + '0';
14. pNode->next = NULL;
15. return pNode;
16. }
17. else
18. {
19. int carry_cur=0;
20. struct node * pNode = new node();
21. struct node * pNext = add( pNode1->next, pNode2->next, carry_cur );
22. int sum = (pNode1->val - '0' ) + ( pNode2->val -'0') + carry_cur;
23. carry = sum/10;
24. pNode->val = sum%10 + '0';
25. pNode->next = pNext;
26. return pNode;
27. }
28. }
30. if( len1>len2 )
31. {
32. int carry_cur=0;
33. struct node * pNode =new node();
34. struct node * pNext = add( pNode1->next, pNode2, carry_cur );
35. int sum = (pNode1->val -'0' ) + carry_cur;
36. carry = sum/10;
37. pNode->val = sum%10 + '0';
38. pNode->next = pNext;
39. return pNode;
40. }
42. if( len1<len2 )
43. {
44. int carry_cur=0;
45. struct node * pNode =new node();
46. struct node * pNext = add( pNode1, pNode2->next, carry_cur );
47. int sum = (pNode2->val -'0' ) + carry_cur;
48. carry = sum/10;
49. pNode->val = sum%10 + '0';
50. pNode->next = pNext;
51. return pNode;
52. }
54. return NULL;
55. }
57. struct node * add(struct node * phead1, struct node * phead2 )
58. {
59. if( !phead1 || !phead1->next )return phead2;
60. if( !phead2 || !phead2->next )return phead1;
62. int carry = 0;
63. struct node * pNode = add( phead1->next, phead2->next, carry );
65. if( carry > 0 ) //有进位，则需要多一个结点
66. {
67. struct node * pCarry =new node();
68. pCarry->val = '0' + carry;
69. pCarry->next = pNode;
70. pNode = pCarry;
71. }
73. struct node * phead =new node();
74. phead->next = pNode;
75. return phead;
76. }
78. void test()
79. {
80. string str;
81. cout << "Input the first link:"<<endl;
82. cin >> str;
83. struct node *phead1 = create( str );
85. cout << "Input the second link:"<<endl;
86. cin >> str;
87. struct node *phead2 = create( str );
89. struct node * phead = add( phead1, phead2);
91. cout<< "The result is:" <<endl;
92. out_link( phead );
94. }
96. int _tmain(int argc, _TCHAR* argv[])
97. {
98. test();
99. return 0;
100. }

//为了参数简洁，这里增大了计算量，可以将链表长度作为参数传进来int len1 = link_length( pNode1 );int len2 = link_length( pNode2 );if( len1 == len2 ){if( len1==1 )             //递归终止条件{struct node * pNode = new node();int sum = (pNode1->val - '0' ) + ( pNode2->val -'0');carry = sum/10;pNode->val = sum%10 + '0';pNode->next = NULL;return pNode;}else{int carry_cur=0;struct node * pNode = new node();struct node * pNext = add( pNode1->next, pNode2->next, carry_cur );int sum = (pNode1->val - '0' ) + ( pNode2->val -'0') + carry_cur;carry = sum/10;pNode->val = sum%10 + '0';pNode->next = pNext;return pNode;}}if( len1>len2 ){int carry_cur=0;struct node * pNode = new node();struct node * pNext = add( pNode1->next, pNode2, carry_cur );int sum = (pNode1->val - '0' ) + carry_cur;carry = sum/10;pNode->val = sum%10 + '0';pNode->next = pNext;return pNode;}if( len1<len2 ){int carry_cur=0;struct node * pNode = new node();struct node * pNext = add( pNode1, pNode2->next, carry_cur );int sum = (pNode2->val - '0' ) + carry_cur;carry = sum/10;pNode->val = sum%10 + '0';pNode->next = pNext;return pNode;}return NULL;}struct node * add( struct node * phead1, struct node * phead2 ){if( !phead1 || !phead1->next ) return phead2;if( !phead2 || !phead2->next ) return phead1;int carry = 0;struct node * pNode = add( phead1->next, phead2->next, carry );if( carry > 0 )                     //有进位，则需要多一个结点{struct node * pCarry = new node();pCarry->val = '0' + carry;pCarry->next = pNode;pNode = pCarry;}struct node * phead = new node();phead->next = pNode;return phead;}void test(){string str;cout << "Input the first link:"<<endl;cin >> str;struct node *phead1 = create( str );cout << "Input the second link:"<<endl;cin >> str;struct node *phead2 = create( str );struct node * phead = add( phead1, phead2);cout<< "The result is:" <<endl;out_link( phead );}int _tmain(int argc, _TCHAR* argv[]){test();return 0;}

思路：

使用哈希表。

从头扫描，将出现过的节点存入哈希表中。

如果元素已经在哈希表中出现过则删除，没有则存入。

注意：

删除时需要知道前一节点。

我使用的链表中存储的是char型变量，所以哈希表即为含有256个元素的数组。

如果存储的是其他数据类型，则可以使用stl中的hash_set容器。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //建立链表
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
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. }
48. //去掉重复元素
49. void delete_repeat_element(struct node * phead )
50. {
51. if( !phead || !phead->next )return;
52. int * hashTable = newint[256](); //加括号是为了将hashTable中所有元素初始化为0
53. struct node * pNode = phead->next;
54. struct node * pPreNode = phead;
55. while( pNode )
56. {
57. if( hashTable[pNode->val] !=0 )//说明已经出现过，该结点要删除
58. {
59. pPreNode->next = pNode->next;
60. delete pNode; //删除结点
61. pNode = pPreNode->next;
62. }
63. else //没有出现过，则置出现标记
64. {
65. hashTable[pNode->val] = 1;
66. pPreNode = pNode;
67. pNode = pNode->next;
68. }
69. }
70. delete [] hashTable; //释放资源
71. }
75. void test()
76. {
77. string str;
78. cout << "Input the link table :"<<endl;
79. cin >> str;
80. struct node *phead = create( str );
82. delete_repeat_element( phead );
84. cout<< "The result is:" <<endl;
85. out_link( phead );
87. }
89. int _tmain(int argc, _TCHAR* argv[])
90. {
91. test();
92. return 0;
93. }

思路1：

将链表中的数据存入数组中，使用数组进行排序，排好后再存入链表中。

当然这并不是这题所要考察的。但是在实际应用中却相当有价值。因为链表中的排序算法都比较慢，进行转存再排序也是一种很好的方法。

思路2：

排序算法有

1， 插入排序：简单插入排序，希尔排序

2， 交换排序：冒泡排序， 快速排序

3， 选择排序：简单选择排序，堆排序

4， 归并排序

5， 基数排序

简单的排序算法有插入，冒泡，选择；

中等的有合并排序，快速排序；

复杂的有堆排序。

我实现了红色的三种排序方法。

使用链表进行排序比较繁琐，尤其是快排，需要拆分，

当然也可以多加一个指针指向要排序的队尾，这样就不用拆了。

[cpp] view plaincopyprint?

1. // LinkTable.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
5. #include <iostream>
6. #include <string>
7. using namespace std;
9. //链表的结构体
10. struct node
11. {
12. char val;
13. node * next;
14. };
16. //建立链表
17. struct node * create( string & str_link )
18. {
19. int len = str_link.length();
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. }
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. }
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. }
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;
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. }
87. //去掉重复元素
88. void delete_repeat_element( struct node * phead )
89. {
90. if( !phead || !phead->next ) return;
91. int * hashTable =new int[256]();//加括号是为了将hashTable中所有元素初始化为0
92. struct node * pNode = phead->next;
93. struct node * pPreNode = phead;
94. while( pNode )
95. {
96. if( hashTable[pNode->val] !=0 )//说明已经出现过，该结点要删除
97. {
98. pPreNode->next = pNode->next;
99. delete pNode; //删除结点
100. pNode = pPreNode->next;
101. }
102. else //没有出现过，则置出现标记
103. {
104. hashTable[pNode->val] = 1;
105. pPreNode = pNode;
106. pNode = pNode->next;
107. }
108. }
109. delete [] hashTable;//释放资源
110. }
112. //插入排序
113. void insert_sort(struct node* phead)
114. {
115. if( !phead || !phead->next)return;
116. struct node *pCur = phead->next->next;//当前处理的结点
117. struct node *pTail = phead->next;//已排好序队列的尾部结点
119. while( pCur )
120. {
121. struct node *pNode = phead->next;//已排好序队列中与当前结点相比较的结点
122. struct node *pPre = phead; //...............前一结点
123. while( pNode != pCur )
124. {
125. if(pNode->val > pCur->val)
126. break;
127. pNode = pNode->next;
128. pPre = pPre->next;
129. }
130. if( pNode == pCur ) //说明已排好序队列中没有比当前元素大的元素
131. {
132. pCur = pCur->next;
133. pTail = pTail->next;
134. }
135. else //将pCur结点插入到pNode之前，即pPre之后
136. {
137. pTail->next = pCur->next;
138. pPre->next = pCur;
139. pCur->next = pNode;
140. pCur = pTail->next;
141. }
142. }
143. }
146. //归并排序
147. //pNode 为待排序链表的第一个元素
148. //找中间结点
149. struct node * find_mid_node(struct node * pNode )
150. {
151. if( !pNode ) return NULL;
152. struct node * pFast = pNode;
153. struct node * pSlow = pNode;
154. int step=1;
155. while( pFast->next )
156. {
157. pFast = pFast->next;
158. if( step++%2==0 )
159. pSlow = pSlow->next;
160. }
161. return pSlow;
162. }
164. //合并之后，pNode1为表头
165. void merge(struct node* &pNode1,struct node* pNode2)
166. {
167. if( !pNode1 ) //特殊情况
168. {
169. pNode1 = pNode2;
170. return;
171. }
172. if( !pNode2 ) return;
174. struct node *pNode = NULL;
175. struct node *phead = NULL;
176. if( pNode1->val < pNode2->val )//找到表头
177. {
178. phead = pNode1;
179. pNode1 = pNode1->next;
180. }
181. else
182. {
183. phead = pNode2;
184. pNode2 = pNode2->next;
185. }
187. pNode = phead;
188. while( pNode1 && pNode2 )
189. {
190. if( pNode1->val < pNode2->val)
191. {
192. pNode->next = pNode1;
193. pNode1 = pNode1->next;
194. }
195. else
196. {
197. pNode->next = pNode2;
198. pNode2= pNode2->next;
199. }
200. pNode = pNode->next;
201. }
202. if( !pNode1 )
203. pNode->next = pNode2;
204. else
205. pNode->next = pNode1;
207. pNode1 = phead;
208. }
210. //注意，这里的pNode是需要变的，所以用了引用，可能不太好理解
211. //如果让返回值指向排行序的表头可能会好一些
212. void merge_sort( struct node * &pNode )
213. {
214. if( !pNode || !pNode->next ) return; //递归终止条件，无结点或者只有一个结点
216. struct node* pMid = find_mid_node( pNode );//分解成两半
217. struct node* pNode2 = pMid->next;
218. pMid->next = NULL;
219. merge_sort( pNode );
220. merge_sort( pNode2 );
221. merge( pNode, pNode2);
222. }
224. //快速排序
225. //划分函数
226. //输入：链表头， 输出：新的链表头，选中的结点
227. struct node * patition(struct node * pNode, struct node * &pSelect )
228. {
229. if( !pNode ) return NULL;
230. struct node* phead = NULL;
231. pSelect = pNode; //选中的元素，划分的依据结点，选最后一个元素
232. while( pSelect->next )
233. pSelect = pSelect->next;
235. struct node *pScan = pNode;
236. struct node *pPre = NULL; //指向pScan前一个结点
237. int flag = 0;
238. while( pScan != pSelect )
239. {
240. if( pScan->val >pSelect->val )//比选中元素大的要掉到选中元素之后
241. {
242. if( !pPre ) //如果是第一个
243. {
244. struct node *temp = pScan;
245. pScan = pScan->next;
246. temp->next = pSelect->next;
247. pSelect->next = temp;
248. }
249. else //如果不是第一个
250. {
251. pPre->next = pScan->next;
252. pScan->next = pSelect->next;
253. pSelect->next = pScan;
254. pScan = pPre->next;
255. }
256. }
257. else
258. {
259. if( flag ==0 )
260. {
261. phead = pScan; //第一个小于选中的元素为表头
262. flag = 1;
263. }
264. pPre = pScan;
265. pScan = pScan->next;
266. }
267. }
268. if( flag == 0 ) // 所有元素都比选中的大，即选中的为表头
269. return pSelect;
270. else
271. return phead;
272. }
274. struct node * QuickSort( struct node * pNode )
275. {
276. if( !pNode || !pNode->next ) return pNode;
277. struct node * pSelect=NULL;
278. pNode = patition( pNode, pSelect );
280. if( pSelect == pNode ) //划分后的结点为第一个结点
281. {
282. pSelect->next = QuickSort(pSelect->next);
283. return pSelect;
284. }
285. else //分两个部分，pSelect前面的和后面的
286. {
287. struct node * pFirstTail = pNode;
288. while( pFirstTail->next != pSelect )
289. pFirstTail = pFirstTail->next;
290. pFirstTail->next = NULL; //断开
291. struct node * phead1 = QuickSort( pNode );//解决前一部分
292. pFirstTail = phead1;
293. while( pFirstTail->next )
294. pFirstTail = pFirstTail->next;
295. pFirstTail->next = pSelect; //连上
296. pSelect->next = QuickSort( pSelect->next ); //解决后一部分
297. return phead1;
298. }
300. }
301. void test()
302. {
303. string str;
304. cout << "Input the link table :"<<endl;
305. cin >> str;
306. struct node *phead = create( str );
308. //insert_sort( phead ); //选中即为插入排序
309. //merge_sort( phead->next ); //选中即为归并排序
310. phead->next = QuickSort( phead->next); //选中即为快速排序
312. cout<< "The result of Sort is:" <<endl;
313. out_link( phead );
315. }
317. int _tmain(int argc, _TCHAR* argv[])
318. {
319. test();
320. return 0;
321. }