几种快速排序的实现(C语言描述)

　　快速排序是对冒泡排序的改进，主要思想是通过一次排序将序列分成两部分，左边的部分全部小于基准值，右边的部分大于基准值。在这一思想下，有不同的几种实现方式。

(以下代码中的测试数据来自用系统时间做种的随机生成序列)

(除了以下版本，还有一些其他的快排的想法。)

1. 比较好理解的版本

 1 /*
 2  *2012年2月13日11:28:00
 3  *quickSort
 4  *这个版本是比较好理解的版本(效率不是最高的)
 5  *quickSort函数第二个参数是要排序的数组起始下标，第三个参数是结束下标
 6  *过程：
 7  *1. 将最左边的数设为val(也即关键字)
 8  *2. 从i开始向右找比val大的数，找到后停下
 9  *3. 从j开始向左找比val小的数，找到后停下
10  *4. 如果i>=j则离开循环
11  *5. 否则：交换当前的两个数
12  *6. 对左边递归
13  *7. 对右边递归
14  */
15 
16 #include <stdio.h>
17 #include <time.h>
18 
19 #define MAX 10
20 #define SWAP(x, y) {int t=x; x=y; y=t;}
21 
22 void quickSort(int *a, int left, int right);
23 
24 int main(void)
25 {
26     int a[MAX] = {0};
27     int i;
28 
29     srand(time(NULL));
30 
31     printf("排序前:\n");
32     for (i=0; i<MAX; i++)
33     {
34         a[i] = rand()%100;
35         printf("%d ", a[i]);
36     }
37 
38     quickSort(a, 0, MAX-1);
39 
40     printf("\n排序后:\n");
41     for (i=0; i<MAX; i++)
42     {
43         printf("%d ", a[i]);
44     }
45     printf("\n");
46 
47     return 0;
48 }
49 
50 void quickSort(int *a, int left, int right)
51 {
52     if (left < right)
53     {
54         int i = left;
55         int j = right+1;
56 
57         while (1)
58         {
59             while (i+1<MAX && a[++i]<a[left]);
60             while (j-1>-1 && a[--j]>a[left]);
61 
62             if (i >= j)
63             {
64                 break;
65             }
66             SWAP(a[i], a[j]);
67         }
68 
69         SWAP(a[left], a[j]);
70 
71         quickSort(a, left, j-1);
72         quickSort(a, j+1, right);
73     }
74 }

2. 对于上述方法进行改进，将基准值设定为序列中间的数，从中间向两边寻找

 1 /*
 2  *2012年2月13日16:26:31
 3  *从中间向两边查找，具体过程类似于容易理解的版本
 4  */
 5 
 6 #include <stdio.h>
 7 #include <time.h>
 8 
 9 #define MAX 10
10 #define SWAP(x, y) {int t=x; x=y; y=t;}
11 
12 void quickSort(int *a, int left, int right);
13 
14 int main(void)
15 {
16     int a[MAX] = {0};
17     int i;
18 
19     srand(time(NULL));
20 
21     printf("排序前:\n");
22     for (i=0; i<MAX; i++)
23     {
24         a[i] = rand()%100;
25         printf("%d ", a[i]);
26     }
27 
28     quickSort(a, 0, MAX-1);
29 
30     printf("\n排序后:\n");
31     for (i=0; i<MAX; i++)
32     {
33         printf("%d ", a[i]);
34     }
35     printf("\n");
36 
37     return 0;
38 }
39 
40 void quickSort(int *a, int left, int right)
41 {
42     if (left < right)
43     {
44         int t = a[(left+right)/2];
45         int i = left - 1;
46         int j = right + 1;
47 
48         while (1)
49         {
50             while (a[++i] < t);
51             while (a[--j] > t);
52 
53             if (i >= j)
54             {
55                 break;
56             }
57             SWAP(a[i], a[j]);
58 
59         }
60 
61         quickSort(a, left, i-1);
62         quickSort(a, j+1, right);
63     }
64 }

3. 再次改进算法。

      有指针left和right，对于right，如果其所指的元素的值大于或者等于基准值，那么指针往左移一位，如果小于基准值，则和基准值交换；同理，对于left，如果left所指元素的值小于或者等于基准值，那么指针往右移一位，如果大于基准值，则和基准值交换。从right开始执行，重复这两步骤，直至left == right为止。

　　对于基准的选取会影响算法的性能，这里取第一个元素为pivot。

 1 /*
 2  *2012年2月13日16:42:45
 3  *效率较高的实现
 4  */
 5 
 6 #include <stdio.h>
 7 #include <time.h>
 8 
 9 #define MAX 10
10 #define SWAP(x, y) {int t=x; x=y; y=t;}
11 
12 void quickSort(int *a, int left, int right);
13 int Partition(int *a, int left, int right);
14 
15 int main(void)
16 {
17     int a[MAX] = {0};
18     int i;
19 
20     srand(time(NULL));
21 
22     printf("排序前:\n");
23     for (i=0; i<MAX; i++)
24     {
25         a[i] = rand()%100;
26         printf("%d ", a[i]);
27     }
28 
29     quickSort(a, 0, MAX-1);
30 
31     printf("\n排序后:\n");
32     for (i=0; i<MAX; i++)
33     {
34         printf("%d ", a[i]);
35     }
36     printf("\n");
37 
38     return 0;
39 }
40 
41 int Partition(int *a, int left, int right)
42 {
43     int pivot = a[left];
44     while (left < right)
45     {
46         while (left < right && a[right] >= pivot)
47         {
48             --right;
49         }
50         a[left] = a[right];
51         while (left < right && a[left] <= pivot)
52         {
53             ++left;
54         }
55         a[right] = a[left];
56     }
57 
58     return left;
59 }
60 
61 void quickSort(int *a, int left, int right)
62 {
63     int pivot;
64 
65     if (left < right)
66     {
67         pivot = Partition(a, left, right);
68         quickSort(a, left, pivot-1);
69         quickSort(a, pivot+1, right);
70     }
71 
72 }