Chinaunix首页 | 论坛 | 博客

路漫漫vincent.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

vincent-cws

  • 博客访问： 956823
  • 博文数量： 116
  • 博客积分： 3923
  • 博客等级： 中校
  • 技术积分： 1337
  • 用 户 组： 普通用户
  • 注册时间： 2009-04-23 01:22
文章分类

全部博文（116）

文章存档

2013年（1）

2012年（17）

2011年（69）

2009年（29）

我的朋友
最近访客
推荐博文
相关博文
基本排序算法C实现

分类： LINUX

2012-01-19 16:43:58

基本排序算法之冒泡排序C实现
基本排序算法之选择排序C实现
基本排序算法之插入排序C实现
基本排序算法之希尔排序C实现
基本排序算法之快速排序C实现
基本排序算法之归并排序C实现
基本排序算法之堆排序C实现

  1. /*
  2.  * file: main.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <time.h>
  11. #include <string.h>

  13. #include "sorts.h"

  15. int compare(const int *d1, const int *d2)
  16. {
  17.     if (*d1 < *d2)
  18.         return -1;
  19.     else if (*d1 > *d2)
  20.         return 1;
  21.     else
  22.         return 0;
  23. }


  26. #define CNTOFARRAY(x) (sizeof(x)/sizeof(x[0]))

  28. #define ARRAY_MAX 10
  29. #define DATA_MAX 100

  31. typedef void (*sort_func)(void*, size_t, size_t, CMP_FUNC, SWAP_FUNC);

  33. void test_random(sort_func fsort)
  34. {
  35.     int rdata, rsize, i, j;
  36.     int *pnew=0;
  37.     srand ((unsigned)time(NULL));    
  38.     
  39.     for (i = 0; i < 10; i++) {
  40.         rsize = rand()%ARRAY_MAX+1;
  41.         pnew = malloc(sizeof(int) * rsize);
  42.         __assert(pnew);
  43.         for (j = 0; j < rsize; j++) {
  44.             rdata = rand()%DATA_MAX;
  45.             rdata = rand()%2 ? -rdata : rdata;
  46.             pnew[j] = rdata;
  47.         }
  48.         printf("------------------------------\n");
  49.         fsort(pnew, rsize, sizeof(int), compare, 0);
  50.         if(pnew) free(pnew);
  51.     }
  52. }
  53. typedef struct sort_s {
  54.     char *p;
  55.     sort_func f;
  56. }sort_t;

  58. #define sort_init(s) {#s,s}

  60. void main()
  61. {
  62.     int i;
  63.     void *p1,*p2,*p3,*p4,*p5;
  64.     const int a1[]={9,7,-2,10,-3,2,8,7,1,0};
  65.     const int a2[]={1,1,1,1,1,1};
  66.     const int a3[]={3};
  67.     const int a4[]={5,2};
  68.     const int a5[]={49,38,65,97,76,13,27,49,55,04};

  70.     sort_t sorts[] = {
  71.         sort_init(bubble_sort),
  72.         sort_init(select_sort),    
  73.         sort_init(insert_sort),
  74.         sort_init(shell_sort),
  75.         sort_init(quick_sort),
  76.         sort_init(merge_sort),
  77.         sort_init(heap_sort),
  78.     };


  81.     p1 = malloc(sizeof(a1));
  82.     p2 = malloc(sizeof(a2));
  83.     p3 = malloc(sizeof(a3));
  84.     p4 = malloc(sizeof(a4));
  85.     p5 = malloc(sizeof(a5));
  86.     __assert (p1 && p2 && p3 && p4 && p5);

  88.     for (i=0; i < CNTOFARRAY(sorts); i++) {
  89.         memcpy(p1, a1, sizeof(a1));
  90.         memcpy(p2, a2, sizeof(a2));
  91.         memcpy(p3, a3, sizeof(a3));
  92.         memcpy(p4, a4, sizeof(a4));
  93.         memcpy(p5, a5, sizeof(a5));
  94.         printf("==========> %s start ==========\n", sorts[i].p);
  95.         sorts[i].f(p1, CNTOFARRAY(a1), sizeof(a1[0]), compare, 0);    
  96.         printf("---------------------------------------------\n");
  97.         sorts[i].f(p2, CNTOFARRAY(a2), sizeof(a2[0]), compare, 0);
  98.         printf("---------------------------------------------\n");
  99.         sorts[i].f(p3, CNTOFARRAY(a3), sizeof(a3[0]), compare, 0);
  100.         printf("---------------------------------------------\n");
  101.         sorts[i].f(p4, CNTOFARRAY(a4), sizeof(a4[0]), compare, 0);
  102.         printf("---------------------------------------------\n");
  103.         sorts[i].f(p5, CNTOFARRAY(a5), sizeof(a5[0]), compare, 0);

  105.         printf("================ random test ... ============\n");
  106.         test_random(sorts[i].f);
  107.         printf("==========> %s end ! ==========\n", sorts[i].p);
  108.     }

  110.     free(p1);
  111.     free(p2);
  112.     free(p3);
  113.     free(p4);
  114.     free(p5);
  115. }

---------------------------------------------------------------------------------------------
  1. /*
  2.  * file: sorts.h
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #ifndef __SORTS_H__
  9. #define __SORTS_H__

  11. #include <stdio.h>
  12. #include <stdlib.h>

  14. #ifndef __assert
  15. #define __assert(x)
  16. #endif

  18. typedef int (*CMP_FUNC)(const void *d1, const void *d2);
  19. typedef void (*SWAP_FUNC)(void *d1, void *d2, unsigned int size);

  21. int cmp_dft(const void *d1, const void *d2);
  22. void swap_dft(void *d1, void *d2, unsigned int size);

  24. void dump_all(void *base, size_t num, size_t size);
  25. int verify(void *base, size_t num, size_t size, CMP_FUNC cmpf);

  27. void bubble_sort(void *base, size_t num, size_t size,
  28.                  CMP_FUNC cmpf, SWAP_FUNC swapf);

  30. void select_sort(void *base, size_t num, size_t size,
  31.             CMP_FUNC cmpf, SWAP_FUNC swapf);

  33. void insert_sort(void *base, size_t num, size_t size,
  34.             CMP_FUNC cmpf, SWAP_FUNC swapf);

  36. void shell_sort(void *base, size_t num, size_t size,
  37.             CMP_FUNC cmpf, SWAP_FUNC swapf);

  39. void quick_sort(void *base, size_t num, size_t size,
  40.             CMP_FUNC cmpf, SWAP_FUNC swapf);
  1. void merge_sort(void *base, size_t num, size_t size,
  2.             CMP_FUNC cmpf, SWAP_FUNC swapf);
  1. void heap_sort(void *base, size_t num, size_t size,
  2.             CMP_FUNC cmpf, SWAP_FUNC swapf);           

  1. #endif

----------------------------------------------------------------------------------------------
  1. /*
  2.  * file: sorts.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #include "sorts.h"

  10. void swap_dft(void *d1, void *d2, unsigned int size)
  11. {
  12.     char t;
  13.     while (size--)
  14.     {
  15.         t = *(char*)d1;
  16.         *((char*)d1)++ = *(char*)d2;
  17.         *((char*)d2)++ = t;
  18.     }
  19. }

  21. void dump_dft(void *d1)
  22. {
  23.     printf("%d ", *(int*)d1);
  24. }

  26. void dump_all(void *base, size_t num, size_t size)
  27. {
  28.     unsigned int i;
  29.     __assert(base);

  31.     for (i=0; i < num; i++) {
  32.         dump_dft((char*)base+i*size);
  33.     }
  34.     printf("\n");
  35. }

  37. int verify(void *base, size_t num, size_t size, CMP_FUNC cmpf)
  38. {
  39.     unsigned int i, c;
  40.     int flag=0, r;
  41.     __assert(base);

  43.     for (i=0; i < num-1; i++) {
  44.         c = i*size;
  45.         r = cmpf((char*)base+c, (char*)base+c+size);
  46.         if (!flag && r)
  47.         {
  48.             flag = (flag=r)<0 ? -1 : 1;
  49.         }
  50.         if(r!=0 && r!=flag) return -1;
  51.     }
  52.     return 0;
  53. }

----------------------------------------------------------------------------------------------
  1. /*
  2.  * file: bubble_sort.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #define DEBUG

  10. #include "sorts.h"

  12. #ifdef DEBUG
  13. #define __dump(b,n,sz) dump_all(b,n,sz)
  14. #define __verify(b,n,sz,cmp) \
  15. { \
  16.     if(verify(b, n, sz, cmp)!=0) \
  17.         printf("\n==>verification failed!\n"); \
  18. }
  19. #else
  20. #define __dump(b,n,sz)
  21. #define __verify(b,n,sz,cmp)
  22. #endif

  24. static void __swap(void *d1, void *d2, size_t size)
  25. {
  26.     unsigned int t = *(unsigned int *)d1;
  27.     *(unsigned int *)d1 = *(unsigned int *)d2;
  28.     *(unsigned int *)d2 = t;
  29. }

  31. void bubble_sort(void *base, size_t num, size_t size,
  32.             CMP_FUNC cmpf, SWAP_FUNC swapf)
  33. {
  34.     unsigned int i, j, c;
  35.     __assert(base && cmpf);
  36.     if (!swapf)
  37.         swapf = (size == 4 ? __swap : swap_dft);
  38.     __dump(base, num, size);
  39.     for (i = 1; i < num; i++){
  40.         for (j = 0; j < num-i; j++){
  41.             c = j*size;
  42.             if (cmpf((char*)base+c, (char*)base+c+size) > 0)
  43.                 swapf((char*)base+c, (char*)base+c+size, size);
  44.         }
  45.         __dump(base, num, size);
  46.     }
  47.     __verify(base, num, size, cmpf);
  48. }

----------------------------------------------------------------------------------------------
  1. /*
  2.  * file: select_sort.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #define DEBUG

  10. #include "sorts.h"

  12. #ifdef DEBUG
  13. #define __dump(b,n,sz) dump_all(b,n,sz)
  14. #define __verify(b,n,sz,cmp) \
  15. { \
  16.     if(verify(b, n, sz, cmp)!=0) \
  17.         printf("\n==>verification failed!\n"); \
  18. }
  19. #else
  20. #define __dump(b,n,sz)
  21. #define __verify(b,n,sz,cmp)
  22. #endif

  24. static void __swap(void *d1, void *d2, size_t size)
  25. {
  26.     unsigned int t = *(unsigned int *)d1;
  27.     *(unsigned int *)d1 = *(unsigned int *)d2;
  28.     *(unsigned int *)d2 = t;
  29. }

  31. void select_sort(void *base, size_t num, size_t size,
  32.             CMP_FUNC cmpf, SWAP_FUNC swapf)
  33. {
  34.     unsigned int i, j;
  35.     void *pmark;
  36.     __assert(base && cmpf);
  37.     if (!swapf)
  38.         swapf = (size == 4 ? __swap : swap_dft);
  39.     __dump(base, num, size);
  40.     for (i = 0; i < num-1; i++) {
  41.         pmark = (char*)base+i*size;
  42.         for (j = i+1; j < num; j++) {
  43.             if (cmpf(pmark, (char*)base+j*size)>0)
  44.                 pmark = (char*)base+j*size;
  45.         }
  46.         swapf(pmark, (char*)base+i*size, size);
  47.         __dump(base, num, size);
  48.     }
  49.     __verify(base, num, size, cmpf);
  50. }

----------------------------------------------------------------------------------------------
  1. /*
  2.  * file: insert_sort.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #define DEBUG

  10. #include "sorts.h"

  12. #ifdef DEBUG

  14. #define __dump(b,n,sz) dump_all(b,n,sz)

  16. #define __verify(b,n,sz,cmp) \
  17. { \
  18.     if(verify(b, n, sz, cmp)!=0) \
  19.         printf("\n==>verification failed!\n"); \
  20. }

  22. #else

  24. #define __dump(b,n,sz)
  25. #define __verify(b,n,sz,cmp)

  27. #endif


  30. static void __swap(void *d1, void *d2, size_t size)
  31. {
  32.     unsigned int t = *(unsigned int *)d1;
  33.     *(unsigned int *)d1 = *(unsigned int *)d2;
  34.     *(unsigned int *)d2 = t;
  35. }

  37. void insert_sort(void *base, size_t num, size_t size,
  38.             CMP_FUNC cmpf, SWAP_FUNC swapf)
  39. {
  40.     unsigned int i, j, c;
  41.     __assert(base && cmpf);
  42.     if (!swapf)
  43.         swapf = (size == 4 ? __swap : swap_dft);
  44.     __dump(base, num, size);
  45.     for (i = 1; i < num; i++){
  46.         for (j = i; j > 0; j--){
  47.             c = j*size;
  48.             if (cmpf((char*)base+c, (char*)base+c-size) < 0)
  49.                 swapf((char*)base+c, (char*)base+c-size, size);
  50.             else
  51.                 break;
  52.         }
  53.         __dump(base, num, size);
  54.     }
  55.     __verify(base, num, size, cmpf);
  56. }
----------------------------------------------------------------------------------------------

  1. /*
  2.  * file: shell_sort.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #define DEBUG

  10. #include "sorts.h"

  12. #ifdef DEBUG
  13. #define __dump(b,n,sz) dump_all(b,n,sz)
  14. #define __verify(b,n,sz,cmp) \
  15. { \
  16.     if(verify(b, n, sz, cmp)!=0) \
  17.         printf("\n==>verification failed!\n"); \
  18. }
  19. #else
  20. #define __dump(b,n,sz)
  21. #define __verify(b,n,sz,cmp)
  22. #endif

  24. static void __swap(void *d1, void *d2, size_t size)
  25. {
  26.     unsigned int t = *(unsigned int *)d1;
  27.     *(unsigned int *)d1 = *(unsigned int *)d2;
  28.     *(unsigned int *)d2 = t;
  29. }

  31. static void __shell_once(void *base, size_t num, size_t size,
  32.             CMP_FUNC cmpf, SWAP_FUNC swapf, unsigned int scale)
  33. {
  34.     unsigned int i, j, c, d, q=0;
  35.     //printf("---> scale : %d \n", scale);
  36.     while (q < scale) {
  37.         for (i = q+scale; i < num; i = i+scale){
  38.             for (j = i; j >= scale; j = j-scale){
  39.                 c = j*size;
  40.                 d = scale*size;
  41.                 if (cmpf((char*)base+c, (char*)base+c-d) < 0)
  42.                     swapf((char*)base+c, (char*)base+c-d, size);
  43.                 else
  44.                     break;
  45.             }
  46.         }
  47.         q++;
  48.     }
  49.     __dump(base, num, size);
  50. }

  52. void shell_sort(void *base, size_t num, size_t size,
  53.             CMP_FUNC cmpf, SWAP_FUNC swapf)
  54. {
  55.     unsigned int s = num;
  56.     __assert(base && cmpf);
  57.     if (!swapf)
  58.         swapf = (size == 4 ? __swap : swap_dft);
  59.     __dump(base, num, size);
  60.     while ((s=(s)>>1) >= 1) {
  61.         __shell_once(base, num, size, cmpf, swapf, (s&0x01)?s:s+1);
  62.     }
  63.     __verify(base, num, size, cmpf);
  64. }
----------------------------------------------------------------------------------------------

  1. /*
  2.  * file: quick_sort.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #define DEBUG

  10. #include "sorts.h"

  12. #ifdef DEBUG

  14. #define __dump(b,n,sz) dump_all(b,n,sz)

  16. #define __verify(b,n,sz,cmp) \
  17. { \
  18.     if(verify(b, n, sz, cmp)!=0) \
  19.         printf("\n==>verification failed!\n"); \
  20. }

  22. #else

  24. #define __dump(b,n,sz)
  25. #define __verify(b,n,sz,cmp)

  27. #endif


  30. static void __swap(void *d1, void *d2, size_t size)
  31. {
  32.     unsigned int t = *(unsigned int *)d1;
  33.     *(unsigned int *)d1 = *(unsigned int *)d2;
  34.     *(unsigned int *)d2 = t;
  35. }


  38. static unsigned int __quick_once(void *base, size_t num, size_t size,
  39.             CMP_FUNC cmpf, SWAP_FUNC swapf)
  40. {
  41.     unsigned int i=0, j=num-1;
  42.     while (1) {
  43.         while (i<j && cmpf((char*)base+i*size, (char*)base+j*size) <= 0)
  44.             j--;
  45.         if (i==j) break;
  46.         swapf((char*)base+i*size, (char*)base+j*size, size);
  47.         i++;
  48.         while (i<j && cmpf((char*)base+i*size, (char*)base+j*size) <= 0)
  49.             i++;
  50.         if (i==j) break;
  51.         swapf((char*)base+i*size, (char*)base+j*size, size);
  52.         j--;
  53.     }
  54.     return i;
  55. }

  57. static void __quick_sort(void *base, size_t num, size_t size,
  58.             CMP_FUNC cmpf, SWAP_FUNC swapf)
  59. {
  60.     unsigned int k;
  61.     __assert(base && cmpf);
  62.     if (!swapf)
  63.         swapf = (size == 4 ? __swap : swap_dft);
  64.     if (num > 1)
  65.     {
  66.         k = __quick_once(base,num,size,cmpf,swapf);
  67.         __quick_sort(base, k, size, cmpf, swapf);
  68.         __quick_sort((char*)base+(k+1)*size, num-k-1, size, cmpf, swapf);
  69.     }
  70. }

  72. void quick_sort(void *base, size_t num, size_t size,
  73.                          CMP_FUNC cmpf, SWAP_FUNC swapf)
  74. {
  75.     __dump(base, num, size);
  76.     __quick_sort(base, num, size, cmpf, swapf);
  77.     __dump(base, num, size);
  78.     __verify(base, num, size, cmpf);
  79. }
----------------------------------------------------------------------------------------------
  1. /*
  2.  * file: merge_sort.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #define DEBUG

  10. #include "sorts.h"

  12. #ifdef DEBUG

  14. #define __dump(b,n,sz) dump_all(b,n,sz)

  16. #define __verify(b,n,sz,cmp) \
  17. { \
  18.     if(verify(b, n, sz, cmp)!=0) \
  19.         printf("\n==>verification failed!\n"); \
  20. }

  22. #else

  24. #define __dump(b,n,sz)
  25. #define __verify(b,n,sz,cmp)

  27. #endif

  29. #define __malloc(x)    malloc(x)
  30. #define __free(x)    free(x)
  31. #define __memcpy(d,s,c) memcpyx(d,s,c)

  33. static void *memcpyx(void *dest, const void*src, size_t n)
  34. {
  35.     char *dest1 = dest;
  36.     const char *src1 = src;
  37.     while(n--)
  38.         *dest1++ = *(char*)src1++;
  39.     return dest;
  40. }

  42. static void __swap(void *d1, void *d2, size_t size)
  43. {
  44.     unsigned int t = *(unsigned int *)d1;
  45.     *(unsigned int *)d1 = *(unsigned int *)d2;
  46.     *(unsigned int *)d2 = t;
  47. }

  49. /*
  50.  * [0 ... m] [m+1 ... num-1]
  51.  */
  52. static void __merge(void *base, size_t num, size_t size, size_t m,
  53.                      CMP_FUNC cmpf, SWAP_FUNC swapf)
  54. {
  55.     unsigned int i=0, j=m+1, c;
  56.     void *ptmp, *pold;
  57.     pold = ptmp = __malloc(num*size);

  59.     __assert(base && ptmp && m <= num);
  60. //    printf("----------> m: %d\n", m);
  61.     while (i<=m && j<num) {
  62.         c = cmpf((char*)base+i*size, (char*)base+j*size)<=0 ? i++ : j++;
  63.         __memcpy(ptmp, (char*)base+c*size, size);
  64.         ptmp = (char*)ptmp+size;
  65.     }
  66.     if (i<=m)
  67.         __memcpy(ptmp, (char*)base+i*size, (m-i+1)*size);
  68.     if (j<num)
  69.         __memcpy(ptmp, (char*)base+j*size, (num-j)*size);
  70.     __memcpy(base, pold, num*size);

  72. //    __dump(base, num, size);
  73.     __free(pold);
  74. }


  77. void merge_sort(void *base, size_t num, size_t size,
  78.                 CMP_FUNC cmpf, SWAP_FUNC swapf)
  79. {
  80.     unsigned int i, c, step=1;
  81.     __assert(base && cmpf);
  82.     if (!swapf)
  83.         swapf = (size == 4 ? __swap : swap_dft);
  84.     __dump(base, num, size);
  85.     while (step < num)
  86.     {
  87.         for(i = 0; i < num; i += 2*step)
  88.         {
  89.             c = (i+2*step)>num?num-i:step*2;
  90.             __merge((char*)base+i*size, c, size, step-1, cmpf, swapf);
  91.         }
  92.         step *= 2;
  93.     }
  94.     __dump(base, num, size);
  95.     __verify(base, num, size, cmpf);
  96. }
----------------------------------------------------------------------------------------------

  1. /*
  2.  * file: heap_sort.c
  3.  * author: vincent.cws2008@gmail.com
  4.  * history:
  5.  * initial @ 2012-01-19
  6.  */

  8. #define DEBUG

  10. #include "sorts.h"

  12. #ifdef DEBUG

  14. #define __dump(b,n,sz) dump_all(b,n,sz)

  16. #define __verify(b,n,sz,cmp) \
  17. { \
  18.     if(verify(b, n, sz, cmp)!=0) \
  19.         printf("\n==>verification failed!\n"); \
  20. }

  22. #else

  24. #define __dump(b,n,sz)
  25. #define __verify(b,n,sz,cmp)

  27. #endif


  30. static void __swap(void *d1, void *d2, size_t size)
  31. {
  32.     unsigned int t = *(unsigned int *)d1;
  33.     *(unsigned int *)d1 = *(unsigned int *)d2;
  34.     *(unsigned int *)d2 = t;
  35. }

  37. /*
  38.  * i is the first position of array need to adjust ...
  39.  */
  40. void heap_adjust(void *base, size_t num, size_t size, int i,
  41.              CMP_FUNC cmpf, SWAP_FUNC swapf)
  42. {
  43.     unsigned int nchild, c;
  44.     void *pmark;
  45.     int t1, t2;
  46.     for (; 2*i+1 < num; i=nchild)
  47.     {
  48.         pmark=(char*)base+i*size;
  49.         nchild = 2*i+1;
  50.         c = nchild*size;
  51.         if (nchild < num-1 && cmpf((char*)base+c, (char*)base+c+size) < 0)
  52.         {
  53.             ++nchild;
  54.             c += size;
  55.         }
  56.         t1 = *(int*)pmark;
  57.         t2 = *(int*)((char*)base+c);
  58.         if (cmpf(pmark, (char*)base+c) < 0)
  59.             swapf(pmark, (char*)base+c, size);
  60.         else
  61.             break;
  62.     }
  63.     __dump(base, num, size);
  64. }

  66. void heap_sort(void *base, size_t num, size_t size,
  67.              CMP_FUNC cmpf, SWAP_FUNC swapf)
  68. {
  69.     int i;
  70.     __assert(base && cmpf);
  71.     if (!swapf)
  72.         swapf = (size == 4 ? __swap : swap_dft);
  73.     __dump(base, num, size);
  74.     
  75.     for (i=num/2-1; i>=0; --i)
  76.     {
  77.         heap_adjust(base, num, size, i, cmpf, swapf);
  78.     }
  79.     for (i=num-1; i>0; --i)
  80.     {
  81.         swapf((char*)base, (char*)base+i*size, size);
  82.         heap_adjust(base, i, size, 0, cmpf, swapf);
  83.     }
  84.     __dump(base, num, size);
  85.     __verify(base, num, size, cmpf);
  86. }


结束！

附件：
 algorithm_sorts.rar  




阅读(4824) | 评论(0) | 转发(0) |
1

上一篇：各种排序算法时间复杂度和空间复杂度表

下一篇：【转】字符串hash算法比较

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6