单链表排序

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

思路1：

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

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

思路2：

排序算法有

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

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

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

4，       归并排序

5，       基数排序

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

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

复杂的有堆排序。

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

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

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

[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. //去掉重复元素  
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. }  
111.   
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;      //已排好序队列的尾部结点  
118.   
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. }  
144.   
145.   
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. }  
163.   
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;  
173.   
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.     }  
186.   
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;  
206.   
207.     pNode1 = phead;  
208. }  
209.   
210. //注意，这里的pNode是需要变的，所以用了引用，可能不太好理解  
211. //如果让返回值指向排行序的表头可能会好一些  
212. void merge_sort( struct node * &pNode )  
213. {  
214.     if( !pNode || !pNode->next ) return;    //递归终止条件，无结点或者只有一个结点  
215.   
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. }  
223.   
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;  
234.   
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. }  
273.   
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 );  
279.   
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.     }  
299.   
300. }  
301. void test()  
302. {  
303.     string str;  
304.     cout << "Input the link table :"<<endl;  
305.     cin >> str;  
306.     struct node *phead = create( str );  
307.       
308.     //insert_sort( phead );                 //选中即为插入排序  
309.     //merge_sort( phead->next );         //选中即为归并排序  
310.     phead->next = QuickSort( phead->next);  //选中即为快速排序  
311.   
312.     cout<< "The result of Sort is:" <<endl;  
313.     out_link( phead );  
314.   
315. }  
316.   
317. int _tmain(int argc, _TCHAR* argv[])  
318. {  
319.     test();  
320.     return 0;  
321. }