Smooth Sort (cpp_smooth_sort.cc)
================================================================================
最好时间复杂度 O(n)
平均时间复杂度 O(nlogn)
最坏时间复杂度 O(nlogn)
空间复杂度 O(1)
是否稳定 否
Smooth Sort基本思想和Heap Sort相同，但Smooth Sort使用的是一种由多个堆组成的优先队列，这种优先队列在取出最大元素后剩余元素可以就地调整成优先队列，所以Smooth Sort不用像Heap Sort那样反向地构建堆，在数据基本有序时可以达到O(n)复杂度。Smooth Sort算法在维基百科上有详细介绍。
Smooth Sort是所有算法中时间复杂度理论值最好的，但由于Smooth Sort所用的优先队列是基于一种不平衡的结构，复杂度因子很大，所以该算法的实际效率并不是很好。
1 #include <cstdio>
2 #include <cstdlib>
3 #include <ctime>
4
5 static unsigned int set_times = 0;
6 static unsigned int cmp_times = 0;
7
8 template<typename item_type> void setval(item_type& item1, item_type& item2) {
9 set_times += 1;
10 item1 = item2;
11 return;
12 }
13
14 template<typename item_type> int compare(item_type& item1, item_type& item2) {
15 cmp_times += 1;
16 return item1 < item2;
17 }
18
19 template<typename item_type> void swap(item_type& item1, item_type& item2) {
20 item_type item3;
21
22 setval(item3, item1);
23 setval(item1, item2);
24 setval(item2, item3);
25 return;
26 }
27
28 static const unsigned int leonardo[] = {
29 1, 1, 3, 5, 9, 15, 25, 41, 67, 109, 177, 287, 465, 753, 1219, 1973,
30 3193, 5167, 8361, 13529, 21891, 35421, 57313, 92735, 150049, 242785,
31 392835, 635621, 1028457, 1664079, 2692537, 4356617, 7049155, 11405773,
32 18454929, 29860703, 48315633, 78176337, 126491971, 204668309, 331160281,
33 535828591, 866988873, 1402817465, 2269806339u, 3672623805u,
34 };
35
36 template<typename item_type> inline void smooth_sort_fix(
37 item_type* array, int current_heap, int level_index, int* levels) {
38 int prev_heap;
39 int max_child;
40 int child_heap1;
41 int child_heap2;
42 int current_level;
43
44 while(level_index > 0) {
45 prev_heap = current_heap - leonardo[levels[level_index]];
46 if(compare(array[current_heap], array[prev_heap])) {
47 if(levels[level_index] > 1) {
48 child_heap1 = current_heap - 1 - leonardo[levels[level_index] - 2];
49 child_heap2 = current_heap - 1;
50 if(compare(array[prev_heap], array[child_heap1])) break;
51 if(compare(array[prev_heap], array[child_heap2])) break;
52 }
53 swap(array[current_heap], array[prev_heap]);
54 current_heap = prev_heap;
55 level_index -= 1;
56 } else break;
57 }
58
59 current_level = levels[level_index];
60 while(current_level > 1) {
61 max_child = current_heap;
62 child_heap1 = current_heap - 1 - leonardo[current_level - 2];
63 child_heap2 = current_heap - 1;
64
65 if(compare(array[max_child], array[child_heap1])) max_child = child_heap1;
66 if(compare(array[max_child], array[child_heap2])) max_child = child_heap2;
67 if(max_child == child_heap1) {
68 swap(array[current_heap], array[child_heap1]);
69 current_heap = child_heap1;
70 current_level -= 1;
71 }
72 else if(max_child == child_heap2) {
73 swap(array[current_heap], array[child_heap2]);
74 current_heap = child_heap2;
75 current_level -= 2;
76 } else break;
77 }
78 return;
79 }
80
81 template<typename item_type> void smooth_sort(item_type* array, int size) {
82
83 int levels[64] = {1};
84 int toplevel = 0;
85 int i;
86
87 for(i = 1; i < size; i++) {
88 if(toplevel > 0 && levels[toplevel - 1] - levels[toplevel] == 1) {
89 toplevel -= 1;
90 levels[toplevel] += 1;
91 } else if(levels[toplevel] != 1) {
92 toplevel += 1;
93 levels[toplevel] = 1;
94 } else {
95 toplevel += 1;
96 levels[toplevel] = 0;
97 }
98 smooth_sort_fix(array, i, toplevel, levels);
99 }
100
101 for(i = size - 2; i > 0; i--) {
102 if(levels[toplevel] <= 1) {
103 toplevel -= 1;
104 } else {
105 levels[toplevel] -= 1;
106 levels[toplevel + 1] = levels[toplevel] - 1;
107 toplevel += 1;
108
109 smooth_sort_fix(array, i - leonardo[levels[toplevel]], toplevel - 1, levels);
110 smooth_sort_fix(array, i, toplevel, levels);
111 }
112 }
113 return;
114 }
115
116 int main(int argc, char** argv) {
117 int capacity = 0;
118 int size = 0;
119 int i;
120 clock_t clock1;
121 clock_t clock2;
122 double data;
123 double* array = NULL;
124
125 // generate randomized test case
126 while(scanf("%lf", &data) == 1) {
127 if(size == capacity) {
128 capacity = (size + 1) * 2;
129 array = (double*)realloc(array, capacity * sizeof(double));
130 }
131 array[size++] = data;
132 }
133
134 // sort
135 clock1 = clock();
136 smooth_sort(array, size);
137 clock2 = clock();
138
139 // output test result
140 fprintf(stderr, "smooth_sort:\t");
141 fprintf(stderr, "time %.2lf\t", (double)(clock2 - clock1) / CLOCKS_PER_SEC);
142 fprintf(stderr, "cmp_per_elem %.2lf\t", (double)cmp_times / size);
143 fprintf(stderr, "set_per_elem %.2lf\n", (double)set_times / size);
144 for(i = 0; i < size; i++) {
145 fprintf(stdout, "%lf\n", array[i]);
146 }
147 free(array);
148 return 0;
149 }