几种常用排序算法的C语言实现

重温数据结构，顺手写下几种常用的排序算法，以备查询。

[cpp] view plain copy print ?

1. #include <stdio.h> 
2. #include <stdlib.h> 
3. #include <assert.h> 
4. #include <malloc.h> 
5. #include <memory.h> 
6. #include <time.h> 
7.  
8. void print(int a[], int n) 
9. { 
10.     int i = 1; 
11.     while(i<=n) 
12.     { 
13.         printf("%d,", a[i]); 
14.         i++; 
15.     } 
16.     printf("/n"); 
17.  
18.     return; 
19. } 
20.  
21. //直接插入排序，时间复杂度O(n^2),空间复杂度O(1)，稳定排序 
22. //a[0]不参与排序，实际排序空间为a[1]~a[n] 
23. void InsertSort(int a[], int n) 
24. { 
25.     for(int i=2; i<=n; i++) 
26.     { 
27.         if(a[i]<a[i-1]) 
28.         { 
29.             a[0] = a[i]; 
30.             int j = i - 1; 
31.             //扫描有序空间， 
32.             while(a[0]<a[j]) 
33.             { 
34.                 a[j+1] = a[j]; 
35.                 j--; 
36.             } 
37.             a[j+1] = a[0]; 
38.         } 
39.     } 
40.     printf("InsertSort : "); 
41.     print(a, n); 
42.  
43.     return; 
44. } 
45.  
46. //一次Shell排序过程 
47. void ShellPass(int a[], int n, int increment) 
48. { 
49.     for(int i=increment+1; i<=n; i++) 
50.     { 
51.         if(a[i]<a[i-increment]) 
52.         { 
53.             a[0] = a[i]; 
54.             int j=i-increment; 
55.             while(j>0 && a[0]<a[j]) 
56.             { 
57.                 a[j+increment] = a[j]; 
58.                 j -= increment; 
59.             } 
60.             a[j+increment] = a[0]; 
61.         } 
62.     } 
63.  
64.     return; 
65. } 
66.  
67. //Shell排序,时间复杂度依赖于增量序列，应避免互为倍数的增量序列， 
68. //目前较好时间复杂度为n^1.25~1.6n^1.25,空间复杂度为O(1)，不稳定排序 
69. void ShellSort(int a[], int n) 
70. { 
71.     int increment = 20; 
72.     do 
73.     { 
74.         increment = increment/3 + 1; 
75.         ShellPass(a, n, increment); 
76.     }while(increment>1); 
77.  
78.     printf("ShellSort : "); 
79.     print(a, n); 
80.  
81.     return; 
82. } 
83.  
84. //冒泡排序,时间复杂度O(n^2),空间复杂度O(1),稳定排序 
85. void BubbleSort(int a[], int n) 
86. { 
87.     for(int i=1; i<n; ) 
88.     { 
89.         int lastExchangePos = n;//记录一次排序中最后一次交换的位置，此位置之前的所有数据都已有序 
90.         for(int j=n-1; j>=i; j--) 
91.         { 
92.             if(a[j+1]<a[j]) 
93.             { 
94.                 a[0] = a[j+1]; 
95.                 a[j+1] = a[j]; 
96.                 a[j] = a[0]; 
97.                 lastExchangePos = j+1; 
98.             } 
99.         } 
100.         i = lastExchangePos; 
101.     } 
102.  
103.     printf("BubbleSort : "); 
104.     print(a, n); 
105.  
106.     return; 
107. } 
108.  
109. 快速排序，平均时间复杂度为O(nlgn),空间复杂度为O(lgn)~O(n),快速排序不稳定。 
110. //C++中快速排序的实现, 
111. void QuickSort(int a[], int low, int high) 
112. { 
113.     srand(time(0)); 
114.     a[0] = a[rand()%(high-low+1)+low];//随机选择基准，改善快排的性能 
115.  
116.     int tmp = 0; 
117.     int i = low, j = high; 
118.     while(i<=j) 
119.     { 
120.         while(i<high && a[i]<a[0]) 
121.             i++; 
122.  
123.         while(j>low && a[j]>a[0]) 
124.             j--; 
125.  
126.         if(i<=j) 
127.         { 
128.             tmp = a[i]; 
129.             a[i] = a[j]; 
130.             a[j] = tmp; 
131.             i++; 
132.             j--; 
133.         } 
134.     } 
135.  
136.     if(j>low) 
137.         QuickSort(a, low, j); 
138.     if(i<high) 
139.         QuickSort(a, i, high); 
140.  
141.     return; 
142. } 
143.  
144. //快速排序的一次划分 
145. int Partition(int a[], int low, int high) 
146. { 
147.     srand(time(0)); 
148.     int pos = rand()%(high-low+1)+low; 
149.     a[0] = a[pos]; 
150.  
151.     a[pos] = a[low]; 
152.  
153.     while(low<high) 
154.     { 
155.         while(low<high && a[0]<a[high]) 
156.             high--; 
157.         if(low<high) 
158.             a[low++] = a[high]; 
159.  
160.         while(low<high && a[0]>a[low]) 
161.             low++; 
162.         if(low<high) 
163.             a[high--] = a[low]; 
164.     } 
165.  
166.     a[low] = a[0]; 
167.  
168.     return low; 
169. } 
170.  
171. //数据结构中标准的快速排序算法 
172. void QSort(int a[], int low, int high) 
173. { 
174.     if(low<high) 
175.     { 
176.         int p = Partition(a, low, high); 
177.         QSort(a, low, p-1); 
178.         QSort(a, p+1, high); 
179.     } 
180.  
181.     return; 
182. } 
183.  
184. //直接选择排序，时间复杂度为O(n^2),空间复杂度为O(1),不稳定排序 
185. void SelectSort(int a[], int n) 
186. { 
187.     for(int i=1; i<=n; i++) 
188.     { 
189.         int min = i; 
190.         for(int j=i+1; j<=n; j++) 
191.         { 
192.             if(a[j]<a[min]) 
193.                 min = j; 
194.         } 
195.         if(min!=i) 
196.         { 
197.             a[0] = a[i]; 
198.             a[i] = a[min]; 
199.             a[min] = a[0]; 
200.         } 
201.     } 
202.  
203.     printf("SelectSort : "); 
204.     print(a, n); 
205.     return; 
206. } 
207.  
208. //调整堆 
209. void Heapify(int a[], int s, int to) 
210. { 
211.     /*
212.     //Heapify方法的递归算法
213.     a[0] = a[s];
214.     int tmp = 2*s;
215.     if(tmp+1<=to && a[tmp]<a[tmp+1])tmp++;
217.     if(tmp<=to && a[0]<a[tmp])
218.     {
219.         a[s] = a[tmp];
220.         a[tmp] = a[0];
221.         Heapify(a, tmp, to);
222.     }*/ 
223.  
224.     //Heapify方法的递推算法 
225.     a[0] = a[s]; 
226.     for(int j=2*s; j<=to; j*=2) 
227.     { 
228.         if(j+1<=to && a[j]<a[j+1])j++; 
229.  
230.         if(j<=to && a[0]>=a[j]) 
231.             break; 
232.  
233.         a[s] = a[j]; 
234.     //  a[j] = a[0]; 
235.         s = j; 
236.     } 
237.     a[s] = a[0]; 
238.  
239.     return; 
240. } 
241.  
242. //堆排序,最坏时间复杂度nlgn,空间复杂度为O(1)，不稳定排序，适合大量数据的排序 
243. void HeapSort(int a[], int n) 
244. { 
245.     for(int j=n/2; j>0; j--) 
246.         Heapify(a, j, n); 
247.  
248.     for(int j=n; j>1; j--) 
249.     { 
250.         a[0] = a[j]; 
251.         a[j] = a[1]; 
252.         a[1] = a[0]; 
253.         Heapify(a, 1, j-1); 
254.     } 
255.  
256.     printf("HeapSort : "); 
257.     print(a, n); 
258.  
259.     return; 
260. } 
261.  
262. //归并排序的一次合并过程 
263. void MergePass(int a[], int low, int mid, int high) 
264. { 
265.     int *p = (int*)malloc(sizeof(int)*(high-low+1)); 
266.     assert(p!=NULL); 
267.  
268.     int *pi = p; 
269.     int i = low, j = mid+1; 
270.     while(i<=mid && j<=high) 
271.         *(pi++) = (a[i]<=a[j])? a[i++] : a[j++]; 
272.  
273.     while(i<=mid) 
274.         *(pi++) = a[i++]; 
275.     while(j<=high) 
276.         *(pi++) = a[j++]; 
277.  
278.     pi = p; 
279.     while(low<=high) 
280.         a[low++] = *(pi++); 
281.  
282.     free(p); 
283.  
284.     return; 
285. } 
286.  
287. //归并排序，时间复杂度O(nlgn),空间复杂度O(n),稳定排序 
288. void MergeSort(int a[], int low, int high) 
289. { 
290.     if(low<high) 
291.     { 
292.         int mid = (low+high)/2; 
293.         MergeSort(a, low, mid); 
294.         MergeSort(a, mid+1, high); 
295.         MergePass(a, low, mid, high); 
296.     } 
297.  
298.     return; 
299. } 
300. int main() 
301. { 
302.     //source[0]不参与排序，做为辅助空间使用 
303.     int source[] = {0, 10, 8, 30, 55, 6, 0, 99, 87, -5, 32, 66, 54, 33, 21, 32, 96, 121, 70}; 
304.     int n = sizeof(source)/sizeof(source[0])-1; 
305.  
306.     int a[sizeof(source)/sizeof(source[0])]; 
307.     memcpy(a, source, sizeof(source)); 
308.     InsertSort(a, n); 
309.  
310.     memcpy(a, source, sizeof(source)); 
311.     ShellSort(a, n); 
312.  
313.     memcpy(a, source, sizeof(source)); 
314.     BubbleSort(a, n); 
315.  
316.     memcpy(a, source, sizeof(source)); 
317.     QuickSort(a, 1, n); 
318.     printf("QuickSort : "); 
319.     print(a, n); 
320.  
321.     memcpy(a, source, sizeof(source)); 
322.     QSort(a, 1, n); 
323.     printf("QSort : "); 
324.     print(a, n); 
325.  
326.     memcpy(a, source, sizeof(source)); 
327.     SelectSort(a, n); 
328.  
329.     memcpy(a, source, sizeof(source)); 
330.     HeapSort(a, n); 
331.  
332.     memcpy(a, source, sizeof(source)); 
333.     MergeSort(a, 1, n); 
334.     printf("MergeSort : "); 
335.     print(a, n); 
336.  
337.     system("pause"); 
338.     return 0; 
339. }