之前已经学习了六种常见的排序算法， 包括 插入排序、 归并排序、 快速排序、 希尔排序、 堆排序、 选择排序 。
从总体情况来看 ： 插入排序， 选择排序的思路比较简单， 容易完成， 时间复杂度为O(n2)。
而希尔排序、归并排序、 快速排序、 堆排序在思路上有难度， 但是时间上都有了很大的提高， 时间复杂度为 O(n*longn)。
为了对几种排序方法有一个直观的印象， 写了一个小的测试程序对以上六种排序方法进行了一个测试。
下面是测试代码 ：
sorts_compare.c :
/***********************************************************/ /* Copyright (C) SA14226214, USTC, 2014-2015 */ /* */ /* FILE NAME : sorsts_compare.c */ /* PRINCIPAL AUTHOR : GaoZhipeng */ /* SUBSYSTEM NAME : sorts_compare */ /* MODULE NAME : insert_sort */ /* LANGUAGE : C */ /* TARGET ENVIRONMENT : ANY */ /* DATE OF FIRST RELEASE : 2015/04/05 */ /* DESCRIPTION : This is a sort program */ /***********************************************************/ /* *Revision log: * *Ceated by GaoZhipeng, 2015/04/05 * */ #include<stdio.h> #include<stdlib.h> #include<time.h> #include"quick_sort.c" #include"merge_sort.c" #include"insert_sort.c" #include"selection_sort.c" #include"shell_sort.c" #include"heap_sort.c" #define MAXSIZE 100000 #define ElementType int #define MAXDATA 65535 int main() { int i; clock_t start, end; double duration; ElementType a[MAXSIZE+1], a0[MAXSIZE+1], a1[MAXSIZE+1], a2[MAXSIZE+1], a3[MAXSIZE+1], a4[MAXSIZE+1], a5[MAXSIZE+1]; srand((unsigned)time(NULL)); for(i=0; i<MAXSIZE; i++) { a[i] = rand()%10000; } a5[0] = MAXDATA; for(i=0; i<MAXSIZE; i++) { a0[i] = a[i]; a1[i] = a[i]; a2[i] = a[i]; a3[i] = a[i]; a4[i] = a[i]; /* a5用于堆排序，下标从1开始 */ a5[i+1] = a[i]; } printf("\n"); /*insert_sort*/ start = clock(); insert_sort(a0, MAXSIZE); end = clock(); duration = (double)(end-start)/CLOCKS_PER_SEC*1000; printf("insert_sort total using : %lf ms\n", duration); /*selection_sort*/ start = clock(); selection_sort(a1, MAXSIZE); end = clock(); duration = (double)(end-start)/CLOCKS_PER_SEC*1000; printf("selection_sort total using : %lf ms\n", duration); /*merge_sort*/ start = clock(); merge_sort(a2, 0, MAXSIZE-1); end = clock(); duration = (double)(end-start)/CLOCKS_PER_SEC*1000; printf("merge_sort total using : %lf ms\n", duration); /*quick_sort*/ start = clock(); quick_sort(a3, 0, MAXSIZE); end = clock(); duration = (double)(end-start)/CLOCKS_PER_SEC*1000; printf("quick_sort total using : %lf ms\n", duration); /*shell_sort*/ start = clock(); shell_sort(a4, MAXSIZE); end = clock(); duration = (double)(end-start)/CLOCKS_PER_SEC*1000; printf("shell_sort total using : %lf ms\n", duration); /*heap_sort*/ start = clock(); heap_sort(a5, MAXSIZE); end = clock(); duration = (double)(end-start)/CLOCKS_PER_SEC*1000; printf("heap_sort total using : %lf ms\n", duration); }
insert_sort.c :
/***********************************************************/ /* Copyright (C) SA14226214, USTC, 2014-2015 */ /* */ /* FILE NAME : insert_sort.c */ /* PRINCIPAL AUTHOR : GaoZhipeng */ /* SUBSYSTEM NAME : sorts_compare */ /* MODULE NAME : insert_sort */ /* LANGUAGE : C */ /* TARGET ENVIRONMENT : ANY */ /* DATE OF FIRST RELEASE : 2015/04/05 */ /* DESCRIPTION : This is a sort program */ /***********************************************************/ /* *Revision log: * *Ceated by GaoZhipeng, 2015/04/05 * */ #define ElementType int void insert_sort(ElementType *a, int LEN) { int i, j, key; for(j=1; j<LEN; j++) { key = a[j]; i = j-1; while(a[i]>key) { a[i+1] = a[i]; i--; } a[i+1] = key; } }
selection_sort.c :
/***********************************************************/ /* Copyright (C) SA14226214, USTC, 2014-2015 */ /* */ /* FILE NAME : heap_sort.c */ /* PRINCIPAL AUTHOR : GaoZhipeng */ /* SUBSYSTEM NAME : sorts_compare */ /* MODULE NAME : heap_sort */ /* LANGUAGE : C */ /* TARGET ENVIRONMENT : ANY */ /* DATE OF FIRST RELEASE : 2015/04/05 */ /* DESCRIPTION : This is a sort program */ /***********************************************************/ /* *Revision log: * *Ceated by GaoZhipeng, 2015/04/05 * */ #define ElementType int void swap(ElementType *a, int i, int j); void selection_sort(ElementType *a, int LEN) { int i, j; int min = 0; for(i=0; i<LEN; i++) { for(j=i; j<LEN; j++) { if(a[j] <= a[min]) { min = j; } } swap(a, i, min); } } void swap(ElementType *a, int i, int j) { ElementType temp = a[i]; a[i] = a[j]; a[j] = temp; }
merge_sort.c :
/***********************************************************/ /* Copyright (C) SA14226214, USTC, 2014-2015 */ /* */ /* FILE NAME : merge_sort.c */ /* PRINCIPAL AUTHOR : GaoZhipeng */ /* SUBSYSTEM NAME : sorts_compare */ /* MODULE NAME : merge_sort */ /* LANGUAGE : C */ /* TARGET ENVIRONMENT : ANY */ /* DATE OF FIRST RELEASE : 2015/04/05 */ /* DESCRIPTION : This is a sort program */ /***********************************************************/ /* *Revision log: * *Ceated by GaoZhipeng, 2015/04/05 * */ #define ElementType int void mergeArray(int a[], int first, int mid, int last) { int i, j, m, n; i = first, m = mid; j = mid+1, n = last; int k = 0; int SIZE = last-first+1; ElementType *temp = (ElementType *)malloc(SIZE*sizeof(ElementType)); while(i<=m && j<=n) { if(a[i] < a[j]) { temp[k++] = a[i++]; } else { temp[k++] = a[j++]; } } while(i<=m) temp[k++] = a[i++]; while(j<=n) temp[k++] = a[j++]; for(i=0; i<k; i++) { a[first+i] = temp[i]; } free(temp); } void merge_sort(ElementType a[], int start, int end) { int mid = (start+end)/2; if(start<end) { merge_sort(a, start, mid); merge_sort(a, mid+1, end); mergeArray(a, start, mid, end); } }
quick_sort.c :
/***********************************************************/ /* Copyright (C) SA14226214, USTC, 2014-2015 */ /* */ /* FILE NAME : quick.c */ /* PRINCIPAL AUTHOR : GaoZhipeng */ /* SUBSYSTEM NAME : sorts_compare */ /* MODULE NAME : quick_sort */ /* LANGUAGE : C */ /* TARGET ENVIRONMENT : ANY */ /* DATE OF FIRST RELEASE : 2015/04/05 */ /* DESCRIPTION : This is a sort program */ /***********************************************************/ /* *Revision log: * *Ceated by GaoZhipeng, 2015/04/05 * */ #define ElementType int void quick_sort(ElementType s[], int l, int r) { if(l<r) { int i = l, j = r, x = s[l]; while(i<j) { while( i<j && s[j]>=x ) { j--; } if(i<j) { s[i++] = s[j]; } while( i<j && s[i]<=x ) { i++; } if(i<j) { s[j--] = s[i]; } } s[i] = x; quick_sort(s, l, i-1); quick_sort(s, i+1, r); } }
shell_sort.c :
/***********************************************************/ /* Copyright (C) SA14226214, USTC, 2014-2015 */ /* */ /* FILE NAME : shell_sort.c */ /* PRINCIPAL AUTHOR : GaoZhipeng */ /* SUBSYSTEM NAME : sorts_compare */ /* MODULE NAME : shell_sort */ /* LANGUAGE : C */ /* TARGET ENVIRONMENT : ANY */ /* DATE OF FIRST RELEASE : 2015/04/05 */ /* DESCRIPTION : This is a sort program */ /***********************************************************/ /* *Revision log: * *Ceated by GaoZhipeng, 2015/04/05 * */ #define ElementType int void shell_swap(ElementType *a, int j, int gap) { ElementType temp = a[j]; a[j] = a[j+gap]; a[j+gap] = temp; } void shell_sort(ElementType *a, int n) { int i, j, gap; for(gap = n/2; gap>0; gap/=2) { for(i = gap; i<n; i++) { for(j = i-gap; j>=0&&a[j]>a[j+gap]; j-=gap) { shell_swap(a, j, gap); } } } }
heap_sort.c :
/***********************************************************/ /* Copyright (C) SA14226214, USTC, 2014-2015 */ /* */ /* FILE NAME : heap_sort.c */ /* PRINCIPAL AUTHOR : GaoZhipeng */ /* SUBSYSTEM NAME : sorts_compare */ /* MODULE NAME : heap_sort */ /* LANGUAGE : C */ /* TARGET ENVIRONMENT : ANY */ /* DATE OF FIRST RELEASE : 2015/04/05 */ /* DESCRIPTION : This is a sort program */ /***********************************************************/ /* *Revision log: * *Ceated by GaoZhipeng, 2015/04/05 * */ #define ElementType int void HeapAdjust(ElementType *a, int s, int m); void HeapSort_Swap(ElementType *a, int i, int j) { ElementType temp = a[i]; a[i] = a[j]; a[j] = temp; } void heap_sort(ElementType *a, int LEN) { int i; for(i=LEN/2; i>0; i--) { HeapAdjust(a, i, LEN); } for(i=LEN; i>1; i--) { HeapSort_Swap(a,1,i); HeapAdjust(a,1,i-1); } } void HeapAdjust(ElementType *a, int s, int m) { ElementType temp; int j; temp = a[s]; for(j=2*s; j<=m; j*=2) { if(j<m && a[j]<a[j+1]) { ++j; } if(temp >= a[j]) { break; } a[s] = a[j]; s = j; } a[s] = temp; }
在Linux下编译生成可执行文件 ：$ : gcc sorts_compare.c -to test
然后运行可执行文件 : $ : ./ test
首先利用随机函数生成一组随机数据， 然后通过对同一组数据进行排序观察各个排序算法所用的时间 ：
1. 把sorts_compare.c 中定义的MAXSIZE定义为1000， 观察结果如下：
可以看到数据量较小（<=1000）时， 各个排序算法的优劣并不能很明显的观察出来。
2. 增加数据量 , 把sorts_compare.c 中定义的MAXSIZE定义为10000， 观察结果如下：
可以看到当数据量增大到10000时，后几种排序算法的优势已经可以看出了。
3. 继续增大数据量到100000, 即对十万组数据进行排序， 观察结果：
可以看出在大数据量的情况下， 快速排序的效率最高， 十万组数据只用了10ms, 而接下来堆排序、归并排序、 希尔排序的基本能在50ms左右完成。
而插入排序和选择排序则上升到了秒级， 分别用了11s 和 21s 。
所以当数据量较大时， 虽然时间复杂度都是O(n*logn)， 但是采用快速排序和堆排序的方式对数据进行排序操作时间开销较小。
