經典排序算法概括筆記(4)

時間  2019-12-14
標籤 經典 排序算法 概括 筆記 简体版
原文   原文鏈接
    前面三篇博文咱們分別回顧了冒泡排序、選擇排序、插入排序、希爾排序、歸併排序、堆排序和快速排序。關於排序算法有幾種分類標準，穩定與非穩定、內部與外部。

   所謂穩定的排序算法，意思是若是待排序序列有相同元素，通過排序算法處理後他們的相對順序和排序前在序列裏的相對順序同樣，這樣咱們就稱該排序算法是穩定；不然就是非穩定的。

   所謂內部排序算法，意思是待排序序列數據量規模較小，排序直接在內存裏就能夠完成的排序算法；而外部排序是針對數據量特別大，不能一次性將全部數據調入內存來，在排序過程當中要不斷地訪問外部存儲設備的排序算法。咱們這裏介紹的七種排序算法，還有一個沒有介紹的基數排序，它們都是內部排序算法。

   下面咱們用實際數據來測試一下這幾種算法的性能。經過前面幾篇博文的複習，我已經將這七種排序算法寫成了一個單獨的工程：
   頭文件innersort.h：

點擊(此處)摺疊或打開 css

  1. /**********************************************
  2.  filename: innersort.h
  3.  **********************************************/
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <stdio.h>

  8. void bubble_sort(int a[],int len);
  9. void select_sort(int a[],int len);
  10. void insert_sort(int a[],int len);
  11. void shell_sort(int a[],int len);
  12. void merge_sort(int a[],int len);
  13. void heap_sort(int a[],int len);
  14. void quick_sort(int a[],int low,int high);
    源文件innersort.c：

點擊(此處)摺疊或打開 html

  1. /******************************************
  2.  filename:innersort.c
  3.  ******************************************/
  4. #include "innersort.h"

  5.
  6. //交換兩個數
  7. void swap(int *a,int *b)
  8. {
  9.     int t;
  10.     t = *a;
  11.     *a = *b;
  12.     *b = t;
  13. }

  15. //冒泡排序
  16. void bubble_sort(int a[],int len)
  17. {
  18.     int i,goon;
  19.     goon = 1;
  20.     while(goon && len--){
  21.         goon = 0;
  22.         for(i=0;i<len;i++){
  23.             if(a[i]>a[i+1]){
  24.                 swap(&a[i],&a[i+1]);
  25.                 goon =1;
  26.             }
  27.         }
  28.     }
  29. }

  31. //選擇排序
  32. void select_sort(int a[],int len)
  33. {
  34.     int i,j,min;
  35.     for(i=0;i<len-1;i++){
  36.         min = i;
  37.         for(j=i+1;j<len;j++)
  38.             if(a[min]>a[j])
  39.                 min = j;
  40.         if(min != i){
  41.             swap(&a[i],&a[min]);
  42.         }
  43.     }
  44. }

  45.
  46. //插入排序
  47. void insert_sort(int a[],int len)
  48. {
  49.     int i,j,tmp;
  50.     for(i=1;i<len;i++){
  51.         for(j=i,tmp=a[i];j>0 && tmp < a[j-1];j--){
  52.             a[j] = a[j-1];
  53.         }
  54.         a[j] = tmp;
  55.     }
  56. }

  57.
  58. //希爾排序
  59. void shell_sort(int a[],int len)
  60. {
  61.     int i,j,tmp,d=len;
  62.     while((d/=2)>0){
  63.         for(i=d;i<len;i++){
  64.             for(j=i,tmp=a[i];j>=d && tmp < a[j-d];j-=d){
  65.                 a[j] = a[j-d];
  66.             }
  67.             a[j] = tmp;
  68.         }
  69.     }
  70. }

  71.
  72. //歸併操做，被歸併排序使用
  73. inline void merge_ops(int a[],int alen,int b[],int blen)
  74. {
  75.         int i,j,k,len=alen+blen;
  76.         int *tmp = (int*)malloc(sizeof(int)*len);

  78.         i=j=k=0;
  79.         while(i<alen && j<blen){
  80.             tmp[k++] = ((a[i]<b[j]) ? a[i++]:b[j++]);
  81.         }

  83.         if(i>=alen && j<blen){
  84.             memcpy(tmp+k,b+j,sizeof(int)*(blen-j));
  85.         }
  86.         if(j>=blen && i<alen){
  87.             memcpy(tmp+k,a+i,sizeof(int)*(alen-i));
  88.         }
  89.         memcpy(a,tmp,sizeof(int)*len);
  90.         free(tmp);
  91. }

  92.
  93. //歸併排序
  94. void merge_sort(int a[],int len)
  95. {
  96.         if(len == 1){
  97.                 return;
  98.         }
  99.         merge_sort(a,len/2);
  100.         merge_sort(a+len/2,len-len/2);
  101.         merge_ops(a,len/2,a+len/2,len-len/2);
  102. }

  103.
  104. //用於堆排序，計算節點i的左子節點
  105. inline int leftChildIndex(int i)
  106. {
  107.         return (2*i+1);
  108. }

  109.
  110. //用於堆排序，計算節點i的右子節點
  111. inline int rightChildIndex(int i)
  112. {
  113.         return (2*i+2);
  114. }

  115.
  116. //將堆調整成大根堆的元操做函數
  117. inline void adjustHeap(int a[],int len,int i)
  118. {
  119.         int l,r,bigger;
  120.         l = leftChildIndex(i);
  121.         r = rightChildIndex(i);

  123.         while(l<len || r<len){
  124.                 if(r<len){
  125.                     bigger = ((a[l]>a[r])?l:r);
  126.                 }else if(l<len){
  127.                     bigger = l;
  128.                 }else{
  129.                     break;
  130.                 }
  131.                 if(a[bigger]>a[i]){
  132.                     swap(&a[i],&a[bigger]);
  133.                     i = bigger;
  134.                     l = leftChildIndex(i);
  135.                     r = rightChildIndex(i);
  136.                 }else
  137.                     break;
  138.         }
  139. }

  140.
  141. //創建大根堆
  142. inline void buildHeap(int a[],int len)
  143. {
  144.         int i;
  145.         for(i=len/2-1;i>=0;i--){
  146.             adjustHeap(a,len,i);
  147.         }
  148. }

  149.
  150. //堆排序
  151. void heap_sort(int a[],int len)
  152. {
  153.         int i;
  154.         buildHeap(a,len);

  156.         while(--len > 0){
  157.             swap(&a[0],&a[len]);
  158.             adjustHeap(a,len,0);
  159.         }
  160. }

  161.
  162. //快速排序中用於拆分子序列的操做接口
  163. inline int partoff(int a[],int low,int high)
  164. {
  165.         int key = a[low];
  166.         while(low<high)
  167.         {
  168.                 while(low<high&&key<=a[high])
  169.                         high--;
  170.                 if(low<high)
  171.                         a[low++] = a[high];

  173.                 while(low<high && key >= a[low])
  174.                         low++;
  175.                 if(low<high)
  176.                         a[high--] = a[low];
  177.         }
  178.         a[low] = key;
  179.         return low;
  180. }

  181.
  182. //快速排序
  183. void quick_sort(int a[],int low,int high)
  184. {
  185.     int index=0;
  186.     if(low<high)
  187.     {
  188.         index = partoff(a,low,high);
  189.         quick_sort(a,low,index-1);
  190.         quick_sort(a,index+1,high);
  191.     }
  192. }

    關於測量函數執行時間有不少方式，clock(), times(), gettimeofday(), getrusage()等，還有經過編譯程序時，打開gcc的-pg選項，而後用gprof來測量，下面是我在網上找到的一個計算函數執行時間的版本，很是感謝博客園的「 靜心盡力」朋友，稍加改造一下，咱們就能夠經過編譯時給Makefile傳遞不一樣的宏選項，打開不一樣的時間測量方式：

點擊(此處)摺疊或打開 算法

  1. /*****************************************************
  2.  filename: common.h
  3.             若是定義了TEST_BY_CLOCK，則採用clock()方式計量函數的執行時間；
  4.             若是定義了TEST_BY_TIMES，則採用times()方式計量函數的執行時間；
  5.             若是定義了TEST_BY_GETTIMEOFDAY，則採用gettimeofday()方式計量函數的執行時間；
  6.             若是定義了TEST_BY_GETRUSAGE，則採用getrusage()方式計量函數的執行時間；
  7.  *****************************************************/
  8. #include <sys/time.h>
  9. #include <sys/resource.h>
  10. #include <unistd.h>
  11. #include <stdio.h>
  12. #include <time.h>
  13. #include <stdlib.h>
  14. #include <string.h>

  16. //用於生成隨機待排序序列
  17. #define random(x) (rand()%x)

  19. static clock_t clockT1, clockT2;
  20. static double doubleT1, doubleT2;

  21.
  22. //非快速排序的統一回調測試接口
  23. typedef void (*sfun)(int a[],int len);
  24. //快速排序的測試接口
  25. typedef void (*sfun2)(int a[],int low,int high);

  26.
  27. /***************************************************
  28.  功能說明：生成隨機待排序序列
  29.  輸入參數：len-隨機序列長度，range-隨機序列裏元素的取值範圍
  30.  輸出參數：無
  31.  返 回 值：隨機序列首地址
  32.  ***************************************************/
  33. int *genArray(int len,int range)
  34. {
  35.     int i = 0;
  36.     int *p = (int*)malloc(sizeof(int)*len);
  37.     if(NULL == p)
  38.         return NULL;
  39.     srand((int)time(0));
  40.     for(i=0;i<len;i++){
  41.         p[i] = random(range);
  42.     }
  43.     return p;
  44. }

  45.
  46. /***************************************************
  47.  功能說明：逐次打印給定序列裏的每個元素
  48.  輸入參數：title-提示符，a-序列首地址，len-序列長度
  49.  輸出參數：無
  50.  返 回 值：無
  51.  ***************************************************/
  52. void printforeach(char *title,int a[],int len)
  53. {
  54.     int i = 0;
  55.     printf("%s: ",title);
  56.     for(i=0;i<len;i++){
  57.         printf("%d ",a[i]);
  58.     }
  59.     printf("\n");
  60. }
  61.  
  62. double getTimeval()
  63. {
  64.     struct rusage stRusage;
  65.     struct timeval stTimeval;
  66. #ifdef TEST_BY_GETTIMEOFDAY
  67.     gettimeofday(&stTimeval, NULL);
  68. #endif

  70. #ifdef TEST_BY_GETRUSAGE
  71.     getrusage(RUSAGE_SELF, &stRusage);
  72.     stTimeval = stRusage.ru_utime;
  73. #endif
  74.     return stTimeval.tv_sec + (double)stTimeval.tv_usec*1E-6;
  75. }
  76.  
  77. void start_check(){
  78. #ifdef TEST_BY_CLOCK
  79.     clockT1 = clock();
  80. #endif

  82. #ifdef TEST_BY_TIMES
  83.     times(&clockT1);
  84. #endif

  86. #ifdef TEST_BY_GETTIMEOFDAY
  87.     doubleT1 = getTimeval();
  88. #endif

  90. #ifdef TEST_BY_GETRUSAGE
  91.     doubleT1 = getTimeval();
  92. #endif
  93. }

  95. void end_check(){
  96. #ifdef TEST_BY_CLOCK
  97.     clockT2 = clock();
  98.     printf("Time result tested by clock = %10.30f\n",
  99.             (double)(clockT2 - clockT1)/CLOCKS_PER_SEC);
  100. #endif

  102. #ifdef TEST_BY_TIMES
  103.     times(&clockT2);
  104.     printf("Time result tested by times = %10.30f\n",
  105.             (double)(clockT2 - clockT1)/sysconf(_SC_CLK_TCK));
  106. #endif

  108. #ifdef TEST_BY_GETTIMEOFDAY
  109.     doubleT2 = getTimeval();
  110.     printf("Time result tested by gettimeofday = %10.30f\n",
  111.             (double)(doubleT2 - doubleT1));
  112. #endif

  114. #ifdef TEST_BY_GETRUSAGE
  115.     doubleT2 = getTimeval();
  116.     printf("Time result tested by getrusage = %10.70f\n",
  117.             (double)(doubleT2 - doubleT1));
  118. #endif
  119. }

  121. void do_test(sfun fun_ptr,int a[],int len){
  122.     start_check();
  123.     (*fun_ptr)(a,len);
  124.     end_check();        
  125. }

  127. void do_test2(sfun2 fun_ptr,int a[],int low,int high){
  128.     start_check();
  129.     (*fun_ptr)(a,low,high);
  130.     end_check();        
  131. }
    最終的測試代碼以下：

點擊(此處)摺疊或打開 shell

  1. #include "common.h"
  2. #include "innersort.h"

  4. #ifdef NOECHO
  5. #define printforeach(...) {}
  6. #endif

  8. int main(int argc,char** argv){
  9.     if(3 != argc){
  10.         printf("Usage: %s total range \n",argv[0]);
  11.         return 0;
  12.     }
  13.     int len = atoi(argv[1]);
  14.     int range = atoi(argv[2]);

  16.     int *p = genArray(len,range);
  17.     int *data = (int*)malloc(sizeof(int)*len);

  19.     memcpy(data,p,4*len);
  20.     printforeach("Pop before",data,len);
  21.     do_test(bubble_sort,data,len);
  22.     printforeach("Pop after ",data,len);

  24.     memcpy(data,p,4*len);
  25.     printforeach("select before",data,len);
  26.     do_test(select_sort,data,len);
  27.     printforeach("select after ",data,len);

  29.     memcpy(data,p,4*len);
  30.     printforeach("Insert before",data,len);
  31.     do_test(insert_sort,data,len);
  32.     printforeach("Insert after ",data,len);

  34.     memcpy(data,p,4*len);
  35.     printforeach("Shell before",data,len);
  36.     do_test(shell_sort,data,len);
  37.     printforeach("Shell after ",data,len);

  39.     memcpy(data,p,4*len);
  40.     printforeach("merge before",data,len);
  41.     do_test(merge_sort,data,len);
  42.     printforeach("merge after ",data,len);

  44.     memcpy(data,p,4*len);
  45.     printforeach("heap before",data,len);
  46.     do_test(heap_sort,data,len);
  47.     printforeach("heap after ",data,len);

  49.     memcpy(data,p,4*len);
  50.     printforeach("quick before",data,len);
  51.     do_test2(quick_sort,data,0,len-1);
  52.     printforeach("quick after ",data,len);

  54.     free(p);
  55.     free(data);
  56.     return 0;
  57. }
    Makefile文件的長相以下：

點擊(此處)摺疊或打開 dom

  1. TARGET = test
  2. SRC = test.c innersort.c
  3. OBJS = $(SRC:.c=.o)
  4. CC = gcc
  5. DEBUG += -pg
  6. INCLUDE = -I.
  8. all:$(TARGET)
  9. $(TARGET):$(OBJS)
  10.     $(CC) $(INCLUDE) $(DEBUG) $(CFLAGS) $(OBJS) -o $(TARGET)
  12. %.o : %.c
  13.     $(CC) $(INCLUDE) $(DEBUG) $(CFLAGS) -c $<
  14. clean:
  15.     rm -fr $(TARGET) *.out $(OBJS)
    最終，測試工程文件夾下的文件結構列表：
    若是要關閉排序先後序列的輸出信息，則執行「make CFLAGS+="-DNOECHO"」，須要採用gettimeofday()來計量函數的實行時間，則執行「make CFLAGS+="-DTIME_BY_GETTIMEOFDAY  -DNOECHO"」；同理須要用clock()來計量，則將TIME_BY_GETTIMEOFDAY替換成TEST_BY_CLOCK。一次測試結果以下：

    在數據量很小的狀況下希爾排序的性能要比快速排序稍微好一點點，可是當數據上量級別後，在七種內部排序算法裏，通過100次測試後發現，快速排序的性能絕對是最優的：
   (測試環境：CPU-AMD 速龍雙核2.1GHz，內存-2G，操做系統-Fedora 17，內核版本-3.3.4)
   在下面的對比圖裏咱們能夠看到，當數據量上10萬後，冒泡排序算法明顯力不從心了，選擇排序和插入排序性能至關，但也有點不可接受。可是當數據量達到百萬後前三種算法已經跑不出結果了，但快速排序和歸併排序算法排列一百萬條數只需不到1秒鐘的時間。當數據量達到一千萬時，快速排序也只需3.8秒左右。因此，結論已經很明顯了。
   固然，上述是我用gettimeofday()測量出的算法性能，感興趣的朋友還能夠用其它幾種方式，或者再對比一下gprof的統計結果，看看快速排序究竟是不是真漢子。    這四篇博文是比較簡單的筆記，也僅複習了常見的幾種內部排序，外部排序算法還有其餘新的算法都沒有涉及，有機會再補充。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程