快排算法

来源：互联网发布：java软件开发学费编辑：程序博客网时间：2024/04/27 10:19

快速排序的思想：

第一步

目标是将给定数组的分成三部分，先选取一个中间数，然后实现在中间数前面的数都不大于中间数，中间数后面的都大于中间数

第二步

在中间数前面和后面的子数组上循环调用快速排序即可

算法伪代码：

QUICKSORT（A, p, r）

if p < r

then q <- PARTITION(A, p, r)

QUICKSORT(A, p, q-1)

QUICKSORT(A, q+1, r)

PARTITION(A, p, r)

x <- A[r]

i <- p-1

for j <- p to r-1

do if A[j] <= x

i+=1

exchange A[i] <-> A[j]

exchange A[i+1] <-> A[r]

return i+1

C实现

                            1 #include <stdio.h>
2 #include <stdlib.h>
                              3 #include <unistd.h>
                              4 void quicksort(int array[],int p,int r);
                              5 int partition(int array[],int ,int);
6 int main(){
                              7     int array[] = {2,8,7,1,3,5,6,4};
8     int len = sizeof(array)/sizeof(int);
                              9     int i;
                             10     quicksort(array,0,len-1);
                             11     for(i = 0;i < len;i++)
                             12             printf("%d ",array[i]);
                             13     printf("\n");
   14     return 0;
                             15 }
   16 void quicksort(int array[],int p,int r){
                             17     if(p < r){
                             18         int q = partition(array,p,r);
                             19         quicksort(array,p,q-1);
                             20         quicksort(array,q+1,r);
                             21     }
   22 }
                             23 int partition(int array[],int p,int r){
                             24     int x = array[r];
                             25     int i = p-1;
                             26     int j = p;
                             27     int temp = 0;
                             28     while(j < r){
                             29         if(array[j] <= x){
                             30             i++;
                             31             temp = array[j];
                             32             array[j] = array[i];

33 array[i] = temp;

                             34         }
                             35         j++;
                             36     }
                             37     temp = array[i+1];
                             38     array[i+1] = array[r];
                             39     array[r] = temp;
                             40     return i+1;
                             41 }

算法时间复杂度分析：

最坏情况

当数组元素出现极其不对称情况时，时间复杂度为T(n) = T(n-1) + O(n)，可以得出T(n) = O(n^2)

最佳情况

当数组元素出现最平衡的划分时，时间复杂度为T(n) = 2T(n/2) + O(n)，可以得出T(n) = O(nlgn)

平均情况 T(n) = O(nlgn)

综上所述，快排的时间效率值与划分的子数组的对称情况有关系，而是否对称与所选择的比较数有关（这里选择的是数组最后一个数，所以上面的算法有一定的不稳定性）。

0 0