《大话数据结构》第9章 排序 9.9 快速排序(上)

9.9.1 快速排序介绍
        终于我们的高手要登场了,如果将来你工作后,你的老板要让你写个排序算法,而你会的算法中竟然没有快速排序,我想你还是不要声张,偷偷去把快速排序算法找来敲进电脑,这样至少你不至于被大伙儿取笑。
        事实上,不论是C++ STL、Java SDK或者.NET FrameWork SDK等开发工具包中的源代码里都能找到它的某种实现版本。 
        快速排序算法最早由图灵奖获得者Tony Hoare设计出来的,他在形式化方法理论,以及ALGOL60 编程语言的发明都有卓越的贡献,是上世纪最伟大的计算机科学家之一。而这快速排序算法只是他众多贡献中的一个小发明而已。
        更牛的是,我们现在要学习的这个快速排序算法,被列为20世纪10大算法之一。我们这些玩编程的人还有什么理由不去学习它呢?
        希尔排序相当于直接插入排序的升级,它们同属于插入排序类,堆排序相当于简单选择排序的升级,它们同属于选择排序类。而快速排序其实就是我们前面认为最慢的冒泡排序的升级,它们都属于交换排序类。即它也是通过不断的比较和移动交换来实现排序的,只不过它的实现,增大了记录的比较和移动的距离,将关键字较大的记录从前面直接移动到后面,关键字较小的记录从后面直接移动到前面,从而减少了总的比较次数和移动交换次数。


9.9.2 快速排序算法
        快速排序(Quick Sort)的基本思想是:通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序的目的。
        从字面上感觉不出它的好处来。假设现在要对数组{50,10,90,30,70,40,80,60,20}进行排序。我们通过代码的讲解来学习快速排序的精妙。
        我们来看代码。

/* 对顺序表L作快速排序 */
void QuickSort(SqList *L)

 QSort(L,
1,L->length);
}

        又是一句代码,和归并排序一样,由于需要递归调用,因此我们外封装了一个函数。现在我们来看QSort的实现。

/* 对顺序表L中的子序列L->r[low..high]作快速排序 */
void QSort(SqList *L,int low,int high)

int pivot;
 
if(low<high)
 {
  pivot
=Partition(L,low,high);  /* 将L->r[low..high]一分为二,算出枢轴值pivot */
  QSort(L,low,pivot
-1);   /*  对低子表递归排序 */
  QSort(L,pivot
+1,high);   /*  对高子表递归排序 */
 }
}

        从这里,你应该能理解前面代码“QSort(L,1,L->length);”中1和L->length代码的意思了,它就是当前待排序的序列最小下标值low和最大下标值high。
        这一段代码的核心是“pivot=Partition(L,low,high);”在执行它之前,L.r的数组值为{50,10,90,30,70,40,80,60,20}。Partition函数要做的,就是先选取当中的一个关键字,比如选择第一个关键字50,然后想尽办法将它放到一个位置,使得它左边的值都比它小,右边的值比它大。我们将这样的关键字称为枢轴(pivot)
        在经过Partition(L,1,9)的执行之后,数组变成{20,10,40,30,50,70,80,60,90},并返回值5给pivot,数字5表明50放置在数组下标为5的位置。此时,计算机把原来的数组变成了两个位于50左和右小数组{20,10,40,30}和{70,80,60,90},而后的递归调用“QSort(L,1,5-1);”和“QSort(L,5+1,9);”语句,其实就是在对{20,10,40,30}和{70,80,60,90}分别进行同样的Partition操作,直到顺序全部正确为止。
        到了这里,应该说理解起来还不算困难。下面我们就来看看快速排序最关键的Partition函数实现是怎么样的。

/* 交换顺序表L中子表的记录,使枢轴记录到位,并返回其所在位置 */
/* 此时在它之前(后)的记录均不大(小)于它。 */
1 int Partition(SqList *L,int low,int high)
2 { 
3  int pivotkey;
4  pivotkey=L->r[low];  /* 用子表的第一个记录作枢轴记录 */
5  while(low<high)      /* 从表的两端交替地向中间扫描 */
6  { 
7    while(low<high&&L->r[high]>=pivotkey)
8    high--;
9    swap(L,low,high); /* 将比枢轴记录小的记录交换到低端 */
10    while(low<high&&L->r[low]<=pivotkey)
11    low++;
12    swap(L,low,high); /* 将比枢轴记录大的记录交换到高端 */
13  }
14  return low;     /* 返回枢轴所在位置 */
15 }

1) 程序开始执行,此时low=1,high=L.length=9。第4行,我们将L.r[low]=L.r[1]=50赋值给枢轴变量pivotkey,如图9-9-1所示。
 


2) 第5~13行为while循环,目前low=1<high=9,执行内部语句。
3) 第7行,L.r[high]= L.r[9]=20≯pivotkey=50,因此不执行第8行。
4) 第9行,交换L.r[low]与L.r[high]的值,使得L.r[1]=20,L.r[9]=50。为什么要交换,就是因为第7行的比较知道,L.r[high]是一个比pivotkey=50(即L.r[low])还要小的值,因此它应该交换到50的左侧,如图9-9-2所示。
 
5) 第10行,当L.r[low]= L.r[1]=20,pivotkey=50,L.r[low]<pivotkey,因此第11行,low++,此时low=2。继续循环,L.r[2]=10<50,low++,此时low=3。L.r[3]=90>50,退出循环。
6) 第12行,交换L.r[low]=L.r[3]与L.r[high]=L.r[9]的值,使得L.r[3]=50,L.r[9]=90。此时相当于将一个比50大的值90交换到了50的右边。注意此时low已经指向了3,如图9-9-3所示。
 
7) 继续第5行,因为low=3<high=9,执行循环体。
8) 第7行,当L.r[high]= L.r[9]=90,pivotkey=50,L.r[high]>pivotkey,因此第8行,high--,此时high=8。继续循环,L.r[8]=60>50,high--,此时high=7。L.r[7]=80>50,high--,此时high=6。L.r[6]=40<50,退出循环。
9) 第9行,交换L.r[low]=L.r[3]=50与L.r[high]=L.r[6]=40的值,使得L.r[3]=40,L.r[6]=50,如图9-9-4所示。
 

10) 第10行,当L.r[low]= L.r[3]=40,pivotkey=50,L.r[low]<pivotkey,因此第11行,low++,此时low=4。继续循环L.r[4]=30<50,low++,此时low=5。L.r[5]=70>50,退出循环。
11) 第12行,交换L.r[low]=L.r[5]=70与L.r[high]=L.r[6]=50的值,使得L.r[5]=50,L.r[6]=70,如图9-9-5所示。
 

12) 再次循环。因low=5<high=6,执行循环体后,low=high=5,退出循环,如图9-9-6所示。
 

13) 最后第14行,返回low的值5。函数执行完成。接下来就是递归调用“QSort(L,1,5-1);”和“QSort(L,5+1,9);”语句,对{20,10,40,30}和{70,80,60,90}分别进行同样的Partition操作,直到顺序全部正确为止。我们就不再演示了。
        通过这段代码的模拟,大家应该能够明白,Partition函数,其实就是将选取的pivotkey不断交换,将比它小的换到它的左边,比它大的换到它的右边,它也在交换中不断的更改自己的位置,直到完全满足这个要求为止。

 


9.9.3 快速排序复杂度分析
        我们来分析一下快速排序法的性能。快速排序的时间性能取决于快速排序递归的深度,可以用递归树来描述递归算法的执行情况。如图9-9-7,它是{50,10,90,30,70,40,80,60,20}在快速排序过程中的递归过程。由于我们的第一个关键字是50,正好是待排序的序列的中间值,因此递归树是平衡的,此时性能也比较好。
 

        在最优情况下,Partition每次都划分得很均匀,如果排序n个关键字,其递归树的深度就为⌊log2n⌋+1(⌊x⌋表示不大于x的最大整数),即仅需递归log2n次,需要时间为T(n)的话,第一次Partiation应该是需要对整个数组扫描一遍,做n次比较。然后,获得的枢轴将数组一分为二,那么各自还需要T(n/2)的时间(注意是最好情况,所以是平分两半)。于是不断的划分下去,我们就有了下面的不等式推断:
T(n)≤2T(n/2) +n,T(1)=0
T(n)≤2(2T(n/4)+n/2) +n=4T(n/4)+2n
T(n)≤4(2T(n/8)+n/4) +2n=8T(n/8)+3n
……
T(n)≤nT(1)+(log2n)×n= O(nlog2n)

 

        也就是说,在最优的情况下,快速排序算法的时间复杂度为O(nlogn)。
        在最坏的情况下,待排序的序列为正序或者逆序,每次划分只得到一个比上一次划分少一个记录的子序列,注意另一个为空。如果递归树画出来,它就是一棵斜树。此时需要执行n-1次递归调用,且第i次划分需要经过n-i次关键字的比较才能找到第i个记录,也就是枢轴的位置,因比较次数为 ,最终其时间复杂度为O(n2)。
        平均的情况,设枢轴的关键字应该在第k的位置(1≤k≤n),那么

        
        由数学归纳法可证明,其数量级为O(nlogn)。
        就空间复杂度来说,主要是递归造成的栈空间的使用,最好情况,递归树的深度为log2n,其空间复杂度也就为O(logn),最坏情况,需要进行n-1递归调用,其空间复杂度为O(n),平均情况,空间复杂度也为O(logn)。
        可惜的是,由于关键字的比较和交换是跳跃进行的,因此,快速排序是一种不稳定的排序方法。

(下篇将讲解快速排序的各种优化)

posted on 2011-04-27 09:10 伍迷 阅读(...) 评论(...) 编辑 收藏

导航