数据结构排序算法汇总

排序算法无疑是学习数据结构中的重点内容，本文将给出排序算法的汇总。

下面是具体的实现：

[cpp] view plain copy print ?

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<time.h>  
4.   
5. #define N 1000000  
6.   
7. int Array[N];  
8. int Temp[N];  
9.   
10. //1、冒泡排序  
11. void BubbleSort(int a[],int n){  
12.     int i,j;  
13.     int temp;  
14.     int tag;  
15.   
16.     for(i=n-1;i>0;i--){  
17.         tag = 0;  
18.         for(j=0;j<i;j++)  
19.               if(a[j]>a[j+1]){  
20.                   temp=a[j];  
21.                   a[j]=a[j+1];  
22.                   a[j+1]=temp;  
23.                   tag=1;  
24.                   }  
25.         if(tag==0) break;  
26.         }  
27.   
28.     }  
29.   
30. //2、简单插入排序  
31. void SimpleInsertSort(int a[],int n){  
32.     int i,j,k;  
33.     int temp;  
34.   
35.     for(i=1;i<n;i++){  
36.         for(j=0;j<i;j++)  
37.                if(a[j]>a[i]){  
38.                    k=j;  
39.                    break;  
40.                    }  
41.         if(j==i) continue;  
42.         temp=a[i];  
43.         for(j=i;j>k;j--)  
44.                a[j]=a[j-1];  
45.         a[k]=temp;  
46.         }  
47.     }  
48.   
49. //3、希尔排序  
50. void ShellSort(int a[],int n,int d){  
51.     int h,i,j,k;  
52.     int temp;  
53.   
54.     do{  
55.         d=d/3+1;  
56.         for(h=0;h<d;h++)  
57.                for(i=h+d;i<n;i+=d){  
58.                    for(j=h;j<i;j+=d)  
59.                           if(a[j]>a[i]){  
60.                               k=j;  
61.                               break;  
62.                               }  
63.                     if(j==i) continue;  
64.                     temp=a[i];  
65.                     for(j=i;j>k;j-=d)  
66.                            a[j]=a[j-d];  
67.                     a[k]=temp;  
68.                    }  
69.         }while(d>1);  
70.     }  
71.   
72. //4、简单选择排序  
73. void SimpleSelectSort(int a[],int n){  
74.     int i,j,k;  
75.     int temp;  
76.     for(i=0;i<n;i++){  
77.         temp=a[i];  
78.         k=i;  
79.         for(j=i+1;j<n;j++)  
80.                if(a[j]<temp){  
81.                    temp=a[j];  
82.                    k=j;  
83.                    }  
84.         if(k!=i){  
85.             temp=a[i];  
86.             a[i]=a[k];  
87.             a[k]=temp;  
88.             }  
89.         }  
90.     }  
91.   
92. //5、堆排序  
93. void CreateHeap(int a[],int n){  
94.     int i,j;  
95.     int temp;  
96.   
97.     for(i=(n-2)/2;i>=0;i--){  
98.         j=2*i+1;  
99.         while(j<n){  
100.             if(j+1<n&&a[j+1]>a[j])  
101.                  j++;  
102.             if(a[(j-1)/2]<a[j]){  
103.                 temp=a[(j-1)/2];  
104.                 a[(j-1)/2]=a[j];  
105.                 a[j]=temp;  
106.                 }  
107.             else break;  
108.              j=2*j+1;  
109.             }  
110.         }  
111.     }  
112.   
113. void HeapAdjust(int a[],int n){  
114.     int i=0;  
115.     int j;  
116.     int temp;  
117.     while(i<n&&2*i+1<n){  
118.         j=2*i+1;  
119.         if(j+1<n&&a[j+1]>a[j])  
120.             j++;  
121.   
122.         if(a[i]<a[j]){  
123.             temp=a[i];  
124.             a[i]=a[j];  
125.             a[j]=temp;  
126.             }  
127.         else break;  
128.         i=j;  
129.         }  
130.     }  
131.   
132. void HeapSort(int a[],int n){  
133.     int i;  
134.     int temp;  
135.     CreateHeap(a,n);  
136.     for(i=n-1;i>0;i--){  
137.         temp=a[i];  
138.         a[i]=a[0];  
139.         a[0]=temp;  
140.         HeapAdjust(a,i);  
141.         }  
142.     }  
143.   
144. //6、快速排序  
145. int partition(int a[],int low,int high){  
146.     int pivotKey=a[low];  
147.     while(low<high){  
148.         while(low<high&&pivotKey<=a[high])  
149.                     high--;  
150.         a[low]=a[high];  
151.         while(low<high&&a[low]<=pivotKey)  
152.                     low++;  
153.         a[high]=a[low];  
154.         }  
155.     a[low]=pivotKey;  
156.     return low;  
157.     }  
158.   
159. void QuickSort(int a[],int low,int high){  
160.     int pivotTag;  
161.     if(low<high){  
162.         pivotTag=partition(a,low,high);  
163.         QuickSort(a,low,pivotTag-1);  
164.         QuickSort(a,pivotTag+1,high);  
165.         }  
166.     }  
167.   
168. //7、归并排序  
169. void Merge(int a[],int p,int q,int r){  
170.     int i,j;  
171.     int *ptr=(int*)malloc((r-p+1)*sizeof(int));  
172.     int begin_1,end_1,begin_2,end_2;  
173.     begin_1=p;  
174.     end_1=q;  
175.     begin_2=q+1;  
176.     end_2=r;  
177.     j=0;  
178.   
179.     while(begin_1<=end_1&&begin_2<=end_2){  
180.         if(a[begin_1]<=a[begin_2]){  
181.             ptr[j]=a[begin_1];  
182.             begin_1++;  
183.             }  
184.         else{  
185.             ptr[j]=a[begin_2];  
186.             begin_2++;  
187.             }  
188.         j++;  
189.         }  
190.   
191.     while(begin_1<=end_1)  
192.                 ptr[j++]=a[begin_1++];  
193.     while(begin_2<=end_2)  
194.                  ptr[j++]=a[begin_2++];  
195.   
196.     for(i=0;i<r-p+1;i++)  
197.            a[p+i]=ptr[i];  
198.   
199.     free(ptr);  
200.     }  
201.   
202. void MergeSort(int a[],int first,int last){  
203.     int mid;  
204.   
205.     if(first<last){  
206.         mid=(first+last)/2;  
207.         MergeSort(a,first,mid);  
208.         MergeSort(a,mid+1,last);  
209.         Merge(a,first,mid,last);  
210.         }  
211.     }  
212.   
213. //8、基数排序(LSD)  
214. int MaxBit(int a[],int n){  
215.     int i;  
216.     int d=1;  
217.     int p=10;  
218.     for(i=0;i<n;i++)  
219.            while(a[i]>=p){  
220.                p*=10;  
221.                ++d;  
222.                }  
223.     return d;  
224.     }  
225.   
226. void RadixSort(int a[],int n){  
227.     int i,j,k;  
228.     int radix=1;  
229.     int d=MaxBit(a,n);  
230.     int *ptr=(int*)malloc(n*sizeof(int));  
231.     int *count=(int*)malloc(10*sizeof(int));  
232.   
233.     for(i=1;i<=d;i++){  
234.         for(j=0;j<10;j++)  
235.                count[j]=0;  
236.   
237.         for(j=0;j<n;j++){  
238.             k=(a[j]/radix)%10;  
239.             count[k]++;  
240.             }  
241.   
242.         for(j=1;j<10;j++)  
243.               count[j]=count[j-1]+count[j];  
244.   
245.         for(j=n-1;j>=0;j--){  
246.             k=(a[j]/radix)%10;  
247.             count[k]--;  
248.             ptr[count[k]]=a[j];  
249.             }  
250.   
251.         for(j=0;j<n;j++)  
252.               a[j]=ptr[j];  
253.   
254.         radix*=10;  
255.         }  
256.   
257.         free(ptr);  
258.         free(count);  
259.     }  
260.   
261. int main(void){  
262.     int i;  
263.     int index;  
264.     clock_t first,second;  
265.   
266.     for(i=0;i<N;i++)  
267.            Array[i]=rand()%N;  
268.   
269.     /*printf("原始数据为：\n"); 
270.     for(i=0;i<N;i++) 
271.           printf("%d\t",Array[i]); 
272.     printf("\n");*/  
273.   
274.     while(1){  
275.         for(i=0;i<N;i++)  
276.                Temp[i]=Array[i];  
277.   
278.         printf("请输入排序方法：\n");  
279.         printf("1---冒泡排序\n");  
280.         printf("2---简单插入排序\n");  
281.         printf("3---希尔排序\n");  
282.         printf("4---简单选择排序\n");  
283.         printf("5---堆排序\n");  
284.         printf("6---快速排序\n");  
285.         printf("7---归并排序\n");  
286.         printf("8---基数排序\n");  
287.         scanf("%d",&index);  
288.         if(index<1||index>8) break;  
289.   
290.        first=clock();  
291.        switch(index){  
292.            case 1: BubbleSort(Temp,N);  
293.                        break;  
294.            case 2: SimpleInsertSort(Temp,N);  
295.                        break;  
296.            case 3: ShellSort(Temp,N,10);  
297.                        break;  
298.            case 4: SimpleSelectSort(Temp,N);  
299.                        break;  
300.            case 5: HeapSort(Temp,N);  
301.                        break;  
302.            case 6: QuickSort(Temp,0,N-1);  
303.                        break;  
304.            case 7: MergeSort(Temp,0,N-1);  
305.                        break;  
306.            default: RadixSort(Temp,N);  
307.         }  
308.        second=clock();  
309.   
310.        /*printf("排序后数据为：\n"); 
311.        for(i=0;i<N;i++) 
312.               printf("%d\t",Temp[i]);*/  
313.   
314.        printf("排序用时：%f秒\n\n",(double)(second-first)/CLOCKS_PER_SEC);  
315.   
316.         }  
317.     return 0;  
318.     }