其他分享
首页 > 其他分享> > 快速排序和归并排序的C语言实现和两者排序在各个量级的数据量下效率对比

快速排序和归并排序的C语言实现和两者排序在各个量级的数据量下效率对比

作者:互联网

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<unistd.h>
 4 #include<string.h>
 5 #include<errno.h>
 6 
 7 #include"fastsort.h"
 8 
 9 #if 0
10 #define DEBUG(...) printf(__VA_ARGS__)
11 #else
12 #define DEBUG(...)
13 #endif
14 
15 
16 /*-fastsort
17  * @d: a pointer to the array which save the data
18  * @datasize: each data's size in byte
19  * @left,right: the min and max index
20  * @cmp: the callback function used to compare the data
21     an example for cmp, assume they are int data, and order from small to big
22     int cmp(void *a, void *b)
23     {
24         return (*((int *)a) < *((int *)b));
25     }
26  */
27 int fastsort(void *d, const int datasize, const int left, const int right, int (*cmp)(void *, void *))
28 {
29     char *data = d;
30     int hole,l,r,ret;
31     void *tempdata = NULL;
32     
33     if(NULL == d || datasize < 1 || left < 0 || right < 0 || NULL == cmp){
34         return -1;
35     }
36     
37     if(left >= right){  // normal exit
38         return 0;
39     }
40     
41     hole = left;
42     l = left;
43     r = right;
44     
45     tempdata = malloc(datasize);
46     if(NULL == tempdata){
47         perror("malloc()");
48         exit(1);
49     }
50 
51     memcpy(tempdata, &data[datasize * hole], datasize);  // tempdata = data[hole];
52     while(l < r){
53         while(l < r){
54             if(cmp(&data[datasize * r], tempdata)){
55                 memcpy(&data[datasize * hole], &data[datasize * r], datasize);
56                 hole = r;
57                 break;
58             }
59             --r;
60         }
61 
62         while(l < r){
63             if(cmp(tempdata, &data[datasize * l])){
64                 memcpy(&data[datasize * hole], &data[datasize * l], datasize);
65                 hole = l;
66                 break;
67             }
68             ++l;
69         }
70     }
71     
72     memcpy(&data[datasize * hole], tempdata, datasize);
73     free(tempdata);
74 
75     // loop
76     if(left < hole-1){
77         ret = fastsort(d, datasize, left, hole-1, cmp);
78         if(ret < 0){
79             printf("(%d)Error %d, from %d to %d\n", __LINE__, ret, left, hole-1);
80             return ret;
81         }
82     }
83     
84     if(hole+1 < right){
85         ret = fastsort(d, datasize, hole+1, right, cmp);
86         if(ret < 0){
87             printf("(%d)Error %d, from %d to %d\n", __LINE__, ret, hole+1, right);
88             return ret;
89         }
90     }
91     return 0;
92 }
fastsort.c
  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<string.h>
  5 #include<errno.h>
  6 
  7 #include"mergesort.h"
  8 
  9 #if 0
 10 #define DEBUG(...) printf(__VA_ARGS__)
 11 #else
 12 #define DEBUG(...)
 13 #endif
 14 
 15 
 16 int mergesort(void *d, const int datasize, const int left, const int right, int (*cmp)(void *, void *))
 17 {
 18     char *data = d;
 19     int diff = right - left;
 20     void *tempdata = NULL;
 21     char *temparr = NULL;
 22     int ret = 0;
 23     int l, r;
 24     int i;
 25 
 26     if(NULL == d || datasize < 1 || left < 0 || right < 0 || NULL == cmp){
 27         printf("Error: bad param\n");
 28         return -1;
 29     }
 30 
 31     if(diff == 0){
 32         return 0;
 33     }
 34 
 35     tempdata = malloc(datasize);
 36     if(NULL == tempdata){
 37         perror("malloc()");
 38         return -1;
 39     }
 40 
 41     if(diff > 1){
 42         //DEBUG("before left(%d\t%d) and right(%d\t%d), the arr is\n", left, left + diff/2, left + diff/2 + 1, right); showarr(d, 10);
 43         // sort left and right part
 44         ret = mergesort(d, datasize, left, left + diff/2, cmp);
 45         if(ret < 0){
 46             printf("Error: in left part (%d, %d)\n", left, left + diff/2);
 47             free(tempdata);
 48             return -1;
 49         }
 50         ret = mergesort(d, datasize, left + diff/2 + 1, right, cmp);
 51         if(ret < 0){
 52             printf("Error: in right part (%d, %d)\n", left + diff/2 + 1, right);
 53             free(tempdata);
 54             return -1;
 55         }
 56 
 57         //DEBUG("after left(%d\t%d) and right(%d\t%d), the arr is\n", left, left + diff/2, left + diff/2 + 1, right); showarr(d, 10);printf("\n\n\n");
 58         
 59         // merge
 60         temparr = malloc(datasize * (right - left + 1));  // save data
 61         if(NULL == temparr){
 62             perror("malloc()");
 63             free(tempdata);
 64             return -1;
 65         }
 66 
 67         l = left;
 68         r = left + diff/2 + 1;
 69         for(i=0;i<(right - left + 1);i++){
 70             if(l <= left + diff/2 && r <= right){
 71                 if( cmp(&data[datasize * l], &data[datasize * r]) ){
 72                     memcpy(&temparr[datasize * i], &data[datasize * l], datasize);
 73                     ++l;
 74                 }
 75                 else{
 76                     memcpy(&temparr[datasize * i], &data[datasize * r], datasize);
 77                     ++r;
 78                 }
 79             }
 80             else{
 81                 if(l > left + diff/2){
 82                     memcpy(&temparr[datasize * i], &data[datasize * r], datasize * (right - left + 1 - i));
 83                 }
 84                 else{
 85                     memcpy(&temparr[datasize * i], &data[datasize * l], datasize * (right - left + 1 - i));
 86                 }
 87                 break;  // no matter which part is over, we just need to copy the rest data in one time and finish for loop
 88             }
 89         }
 90         // in temparr, the data has been sorted
 91         memcpy(&data[datasize * left], temparr, datasize * (right - left + 1));
 92         free(temparr);
 93     }
 94     else if(diff == 1){ // only 2 data to compare
 95         if(! cmp(&data[datasize * left], &data[datasize * right])){
 96             memcpy(tempdata, &data[datasize * left], datasize);
 97             memcpy(&data[datasize * left], &data[datasize * right], datasize);
 98             memcpy(&data[datasize * right], tempdata, datasize);
 99         }
100     }
101     else if(diff < 0){  // should not happen
102         printf("Error: wrong diff %d\n", diff);
103         ret = -1;
104     }
105 
106     free(tempdata);
107     return ret;
108 }
mergesort.c
  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<string.h>
  5 #include<errno.h>
  6 
  7 #include<time.h>
  8 
  9 #include"fastsort.h"
 10 #include"mergesort.h"
 11 
 12 
 13 #if 0
 14 #define DEBUG(...) printf(__VA_ARGS__)
 15 #else
 16 #define DEBUG(...)
 17 #endif
 18 
 19 #define TEST_HOWMANY_DATASIZE (1)
 20 
 21 
 22 /*
 23 struct timespec {
 24     time_t     tv_sec;        // seconds 
 25     long     tv_nsec;        // nanoseconds
 26 };
 27 */
 28 
 29 void showarr(int *arr, int size)
 30 {
 31     for(int i=0;i<size;i++){
 32         printf("%d\t", arr[i]);
 33     }
 34     printf("\n\n\n");
 35     return;
 36 }
 37 
 38 int cmp(void *a, void *b)
 39 {
 40     return (*((int *)a) < *((int *)b));
 41 }
 42 
 43 
 44 #if 0 // basic test
 45 int main(void)
 46 {
 47     int arr1[] = {50   ,   92   ,   67  ,    64  ,    70    ,  79   ,   96  ,    7    ,   6     ,  3};
 48     showarr(arr1, sizeof(arr1)/sizeof(*arr1));
 49     mergesort(arr1, sizeof(*arr1), 0, sizeof(arr1)/sizeof(*arr1) - 1, cmp);
 50     showarr(arr1, sizeof(arr1)/sizeof(*arr1));
 51     return 0;
 52 }
 53 
 54 #else
 55 
 56 #define TEST_DATASIZE (2200)
 57 #define LOOP_TIMES (10000)
 58 
 59 int main(int argc, char *argv[])
 60 {
 61     int arr1[TEST_DATASIZE],arr2[TEST_DATASIZE];
 62     int i,j;
 63     long long int fast_time = 0, merge_time = 0;
 64     struct timespec start_time,end_time;
 65 
 66 #if TEST_HOWMANY_DATASIZE
 67     long int f1, m1;
 68     int fast_win_count = 0;
 69 #endif
 70 
 71     
 72     srand(time(NULL));
 73     for(j=0;j<LOOP_TIMES;j++){
 74         for(i=0;i<TEST_DATASIZE;i++){
 75                 arr1[i] = rand();
 76         }
 77         memcpy(arr2, arr1, sizeof(arr2));
 78         //showarr(arr1, TEST_DATASIZE);
 79         clock_gettime(CLOCK_REALTIME, &start_time);
 80         fastsort(arr1, sizeof(int), 0, sizeof(arr1)/sizeof(*arr1) -1, cmp);
 81         clock_gettime(CLOCK_REALTIME, &end_time);
 82         fast_time += ( 1e9 * (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec) );
 83 
 84 #if TEST_HOWMANY_DATASIZE
 85         long int f1, m1;
 86         f1 = ( 1e9 * (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec) );
 87         DEBUG("%d\ttime fast  :%ld\n", j+1, f1);
 88 #endif
 89 
 90         clock_gettime(CLOCK_REALTIME, &start_time);
 91         mergesort(arr2, sizeof(int), 0, sizeof(arr1)/sizeof(*arr1) -1, cmp);
 92         clock_gettime(CLOCK_REALTIME, &end_time);
 93         merge_time += ( 1e9 * (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec) );
 94 
 95 #if TEST_HOWMANY_DATASIZE
 96         m1 = ( 1e9 * (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_nsec - start_time.tv_nsec) );
 97         DEBUG("%d\ttime merge :%ld\n\n", j+1, m1);
 98         if(f1 < m1){
 99             ++fast_win_count;
100         }
101 #endif
102     }
103 
104     //showarr(arr1, TEST_DATASIZE);
105     //showarr(arr2, TEST_DATASIZE);
106     
107     printf("test data %d loop %d times\n", TEST_DATASIZE, LOOP_TIMES);
108     printf("fast  spend time %lld ns\n", fast_time);
109     printf("merge spend time %lld ns\n", merge_time);
110 #if TEST_HOWMANY_DATASIZE
111     printf("total %d times, fast win %d times(%f%%)\n", LOOP_TIMES, fast_win_count, (100.0*fast_win_count/LOOP_TIMES));
112 #endif
113 
114 
115     return 0;
116 }
117 #endif
main.c
gsp@gsp-VirtualBox:~/share_to_win10/gsp/basic/sort_realize$ ./main
test data 2200 loop 10000 times
fast  spend time 12710266257 ns
merge spend time 15906010158 ns
total 10000 times, fast win 8389 times(83.890000%)
gsp@gsp-VirtualBox:~/share_to_win10/gsp/basic/sort_realize$ ./main
test data 2200 loop 10000 times
fast  spend time 12580529048 ns
merge spend time 14882789401 ns
total 10000 times, fast win 8553 times(85.530000%)
gsp@gsp-VirtualBox:~/share_to_win10/gsp/basic/sort_realize$ 

 

粗略的测了一下:

数据在1000~5000的区间里,快速排序(fast)比归并排序(merge)用时少的概率是80%左右。

数据在100~1000的区间里,快速排序(fast)比归并排序(merge)用时少的概率是90%左右。

如果数据超过5000,数据越大,快速排序的优势好像越不明显了,就是说上述的概论在向50%趋近。

 

PS:上述测试在Ubuntu16.04 x64虚拟机上测的。

PPS:效率的差异和我写的代码质量有没有关系也没有具体分析。和我测试的环境有没有关系也不清楚。

 

标签:排序,int,C语言,include,right,数据量,datasize,data,left
来源: https://www.cnblogs.com/gsp1004/p/16436370.html