单链表排序

因为单链表不能按照下表索引访问元素，因此不能够进行远程交换排序、或者动态分治法排序，能想到的只是相邻元素交换的冒泡排序。

代码：

1. #include <iostream> 
2. using namespace std; 
3.  
4. /* 
5. * 编程实现单链表的排序 
6. */ 
7. typedef struct Student{ 
8.     int data; 
9.     struct Student *next; 
10. }node; 
11.  
12. //获取单链表的长度 
13. int lenList(node* head){ 
14.     if(head==NULL) return 0; 
15.     node *p = head; 
16.     int sum=0; 
17.     while(p!=NULL){ 
18.         sum+=1; 
19.         p=p->next; 
20.     } 
21.     return sum; 
22. } 
23.  
24. //对单链表排序，因为单链表不能随机访问，只能相邻交换 
25. void sortList(node* head){ 
26.     int len = lenList(head); 
27.     cout<<"len:"<<len<<endl; 
28.     if(len==0) return; 
29.     node *p = head; 
30.     for(int i=1; i<len; ++i){ 
31.         //i表示冒泡的次数，共len-1次 
32.         p = head; 
33.         for(int j=0; j<len-i; j++){ 
34.             //j表示下落的数目 
35.             if(p->data < p->next->data){ 
36.                 int tmp = p->data; 
37.                 p->data = p->next->data; 
38.                 p->next->data = tmp; 
39.             } 
40.             p=p->next; 
41.         } 
42.     } 
43. } 
44.  
45. void printList(node* head){ 
46.     node *p = head; 
47.     cout<<"List:"<<endl; 
48.     while(p!=NULL){ 
49.         cout<<p->data<<" "; 
50.         p=p->next; 
51.     } 
52.     cout<<endl; 
53. } 
54.  
55. void main(){ 
56.     int arr[10] = {3,4,9,1,5,2,8,0,6,7}; 
57.     node* head = (node*)malloc(sizeof(node)); 
58.     head->data = arr[0]; 
59.     head->next = NULL; 
60.  
61.     node *p = NULL; 
62.     for(int i=1; i<10; ++i){ 
63.         p = (node*)malloc(sizeof(node)); 
64.         p->data = arr[i]; 
65.         p->next = head->next; 
66.         head->next = p; 
67.     } 
68.     printList(head); 
69.     sortList(head); 
70.     printList(head); 
71.     system("pause"); 
72. } 

运行结果：

转自：http://www.guolairen.com/bishi/767241.html