桶排序

1. #include <iostream>  
2.  2 #include <list>  
3.  3   
4.  4 using namespace std;  
5.  5   
6.  6 struct Node  
7.  7 {  
8.  8     double value;  
9.  9     Node *next;  
10. 10 };  
11. 11 //桶排序主程序  
12. 12 void bucketSort(double* arr, int length)  
13. 13 {  
14. 14     Node key[10];  
15. 15     int number = 0;  
16. 16     Node *p, *q;//插入节点临时变量  
17. 17     int counter = 0;  
18. 18     for(int i = 0; i < 10; i++)  
19. 19     {  
20. 20         key[i].value = 0;  
21. 21         key[i].next = NULL;  
22. 22     }  
23. 23   
24. 24     for(int i = 0; i < length; i++)  
25. 25     {  
26. 26         Node *insert = new Node();  
27. 27         insert->value = arr[i];  
28. 28         insert->next = NULL;  
29. 29         number = arr[i] * 10;  
30. 30         if(key[number].next == NULL)  
31. 31         {  
32. 32             key[number].next = insert;  
33. 33         }  
34. 34         else  
35. 35         {  
36. 36             p = &key[number];  
37. 37             q = key[number].next;  
38. 38             while((q != NULL) && (q->value <= arr[i]))  
39. 39             {  
40. 40                 q = q->next;  
41. 41                 p = p->next;  
42. 42             }  
43. 43             insert->next = q;  
44. 44             p->next = insert;  
45. 45         }  
46. 46     }  
47. 47     for(int i = 0; i < 10; i++)  
48. 48     {  
49. 49         p = key[i].next;  
50. 50         if(p == NULL)  
51. 51             continue;  
52. 52         while(p != NULL)  
53. 53         {  
54. 54             arr[counter++] = p->value;  
55. 55             p = p->next;  
56. 56         }  
57. 57     }  
58. 58 }  
59. 59   
60. 60 int main()  
61. 61 {  
62. 62     double a[] = {0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68};  
63. 63     bucketSort(a, 10);  
64. 64     for(int i = 0; i < 10; i++)  
65. 65     {  
66. 66         cout << a[i] << " ";  
67. 67     }  
68. 68     cout << endl;  
69. 69     return 0;  
70. 70 }  
71. 算法思想：桶排序假设序列由一个随机过程产生，该过程将元素均匀而独立地分布在区间[0,1)上。基本思想是：把区间[0,1)划分成n个相同大小的子区间，称为桶。将n个记录分布到各个桶中去。如果有多于一个记录分到同一个桶中，需要进行桶内排序。最后依次把各个桶中的记录列出来即得到有序序列。