算法---4.快速排序

1. 快速排序
中间partition的过程就是一个swap的过程，
保存key
右/左->左/右           -->整个过程是一个swap，但这儿是个单向的赋值
key->左/右

第1趟按arr[0],分成左右两部分
左部分与右部分再按上述过程递归

1.2 代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define dbmsg(fmt, args ...) printf("%s:%s[%d]: "fmt"\n", __FILE__,__FUNCTION__, __LINE__,##args)
   
4. #define SWAP(x,y) (x=(x)+(y),y=(x)-(y),x=(x)-(y))
   
5. 
   
6. int dump_arry(int* arr, int len)
   
7. {
   
8.     int i;
   
9.     for(i=0; i<len; i++)
   
10.     {
    
11.         //printf("%d=%d ", i, arr[i]);
    
12.         printf("%d ", arr[i]);
    
13.     }
    
14.     printf("\n");
    
15.     return 0;
    
16. }
    
17. 
    
18. int partition(int* arr, int low, int high)
    
19. {
    
20.     int i, j;
    
21.     int pivotkey;
    
22.     if(low >= high)
    
23.         return 0;
    
24.     pivotkey = arr[low];    //以第一个数据为基准分为左小右大的两部分
    
25.     while(low < high)
    
26.     {
    
27.         while( (low<high) && (arr[high]>=pivotkey) )
    
28.             high--;
    
29.         arr[low] = arr[high];
    
30.         dump_arry(arr, 10);
    
31. 
    
32.         while( (low<high) && (arr[low]<=pivotkey) )
    
33.             low++;
    
34.         arr[high] = arr[low];
    
35.         dump_arry(arr, 10);
    
36.     }
    
37.     arr[low] = pivotkey;
    
38.     dump_arry(arr, 10);
    
39.     return low;
    
40. }
    
41. 
    
42. int quick_sort(int* arr, int low, int high)
    
43. {
    
44.     int pivotloc = partition(arr, low, high);
    
45.     dbmsg("pivotloc=%d", pivotloc);
    
46.     if(low < high)   //以第一个数据为基准分为左小右大的两部分，这样一直分一直分，直到low<high< span="" style="word-wrap: break-word;">
    
47.     {
    
48.         dbmsg("left");
    
49.         quick_sort(arr, low, pivotloc-1);
    
50.         dbmsg("right");
    
51.         quick_sort(arr, pivotloc+1, high);
    
52.     }
    
53.     return 0;
    
54. }
    
55. int main ( int argc, char *argv[] )
    
56. {
    
57.     //int arr[] = {49, 38, 65, 97, 76, 13, 27, 49};
    
58.     int arr[] = {49, 38, 65, 97, 76, 13, 27, 49, 55, 4};
    
59.     int len = sizeof(arr)/sizeof(int);
    
60.     dbmsg("len=%d", len);
    
61.     dbmsg("before quick:");
    
62.     dump_arry(arr, len);
    
63.     quick_sort(arr, 0, len-1);
    
64.     dbmsg("after quick:");
    
65.     dump_arry(arr, len);
    
66.     return EXIT_SUCCESS;
    
67. }

1.3 运行结果

1. quick.c:main[52]: before quick:
   
2. 49 38 65 97 76 13 27 49 55 4 
   
3. 
   
4. 4 38 65 97 76 13 27 49 55 4 
   
5. 4 38 65 97 76 13 27 49 55 65 
   
6. 4 38 27 97 76 13 27 49 55 65 
   
7. 4 38 27 97 76 13 97 49 55 65 
   
8. 4 38 27 13 76 13 97 49 55 65 
   
9. 4 38 27 13 76 76 97 49 55 65 
   
10. 4 38 27 13 76 76 97 49 55 65 
    
11. 4 38 27 13 76 76 97 49 55 65 
    
12. 4 38 27 13 49 76 97 49 55 65    -->按49分成左右两部分
    
13. 4 38 27 13 49 76 97 49 55 65    -->49的left再4分成左右两部分
    
14. 4 13 27 13 49 76 97 49 55 65 
    
15. 4 13 27 13 49 76 97 49 55 65 
    
16. 4 13 27 38 49 76 97 49 55 65 
    
17. 4 13 27 38 49 76 97 49 55 65 
    
18. 4 13 27 38 49 65 97 49 55 65 
    
19. 4 13 27 38 49 65 97 49 55 97 
    
20. 4 13 27 38 49 65 55 49 55 97 
    
21. 4 13 27 38 49 65 55 49 55 97 
    
22. 4 13 27 38 49 49 55 49 76 97 
    
23. 4 13 27 38 49 49 55 49 76 97 
    
24. 4 13 27 38 49 49 55 65 76 97 
    
25. 4 13 27 38 49 49 55 65 76 97 
    
26. 
    
27. quick.c:main[55]: after quick:
    
28. 4 13 27 38 49 49 55 65 76 97

1.4 性能
O(nlogn)
1.5 代码打包
quick.rar   (下载后改名为quick.tar.gz