算法导论：快速排序优化算法！

常见快速排序：时间复杂度最好情况下O(nlgn)，最坏情况O(n2)

快速排序是基于分治模式的：

分解：数组A【p..r】被划分成两个（可能空）子数组A【p..q-1】和A【q+1..r】，使得A【p..q-1】中的每个元素都小于等于A(q)，而且，小于等于A【q+1..r】中的元素。下标q 也在返个划分过程中迕行计算。

解决：通过递归调用快速排序，对子数组A【p..q-1】和A【q+1..r】排序。

合并：因为两个子数组使就地排序的，将它们的合并不需要操作：整个数组A【p..r】已排序。

void quicksort(int arr[], int low, int high)
{
    if(low < high)
    {
        int pi = partition(arr, low, high);
        
        quicksort(arr, low, pi-1);
        quicksort(arr, pi+1, high);
    }
}

快排的运行时间与Partition的划分有关

最坏情况是输入的数组已经完全排好序，那么每次划分的左、右两个区域分别为n-1和0，效率为O( n^2 ).

而对于其他常数比例划分，哪怕是左右按9:1的比例划分，效果都是和在正中间划分一样快的（算法导论上有详细分析）

即，任何一种按照常数比例进行划分，总运行时间都是O（n lg n）.

快排的随机化版本：

扫描二维码关注公众号，回复： 128141 查看本文章

因为快排中Partition所产生的划分中可能会有”差的“，而划分的关键在于主元A【r】的选择。我们可以采用一种不同的、称为随机取样的随机化技术，把主元A【r】和A【p..r】中随机选出一个元素交换，这样相当于，我们的主元不在是固定是最后一个A【r】，而是随机从p,...,r这一范围随机取样。这样可以使得期望平均情况下，Partition的划分能够比较对称.

快排的进一步优化的讨论：

1、尾递归：

传统的递归算法在很多时候被视为洪水猛兽. 它的名声狼籍, 好像永远和低效联系在一起，尾递归是极其重要的，不用尾递归，函数的堆栈耗用难以估量，需要保存很多中间函数的堆栈。

快排中的堆栈深度：

QUICKSORT算法包含两个对其自身的递归调用，即调用PARTITION后，左边的子数组和右边的子数组分别被递归排序。QUICKSORT中的第二次递归调用并不是必须的，可以用迭代控制结构来代替它，这种技术叫做“尾递归”，大多数的编译器也使用了这项技术

下面这个版本模拟了尾递归：

QUICKSORT'(A, p, r)

1 while p < r

2 do ▸ Partition and sort left subarray.

3 q ← PARTITION(A, p, r)

4 QUICKSORT'(A, p, q - 1)

5 p ← q + 1

需要注意第一行是 while而不是if

但是这个版本在最坏的情况下，就是划分不好的时候，递归深度为O(n)，可以再进一步优化使栈深度为O（lg n）吗？

用二分的思想，为了使最坏情况下栈的深度为Θ(lgn),我们必须是PARTITION后左边的子数组为原来数组的一半大小，这样递归的深度最多为Θ(lgn)。

一种可能的算法是：首先求得(A, p, r)的中位数，作为PARTITION的枢轴元素，这样可以保证左右两边的元素的个数尽可能的均衡。

因为求中位数的过程MEDIAN的时间复杂度为Θ(n)，因此可以保证算法的期望的时间复杂度O(nlgn)不变。

2. "三数取中"划分

所谓“三数取中”是指，从子数组中随机选出三个元素，取其中间数作为主元，这算是前面随机化版本的升级版。虽然是升级版，但是也只能影响快速排序时间复杂度O（nlgn）的常数因子.

下面将给出综合了”优化的尾递归“+”三数取中“版本的Final 快排版本：

//  优化的尾递归 + 三数取中 版本快排 
#include<cstdio>
#include<ctime>
#include<cstdlib>
  
 
void Swap(int &a,int &b){ if(a!=b){a^=b;b^=a;a^=b;} }  //如果两个数相等，就不执行位运算交换。因为如果两数相等，结果会是0
 
 
int Partition(int *A,int p,int r){
    int x, i;
    x=A[r];
    i=p-1;
    for(int j=p; j<=r-1; ++j){
        if(A[j]<=x) {
            Swap(A[++i], A[j]);    
        }
    }
    Swap(A[++i],A[r]);
    return i;
}

inline int Random(int m,int n){
    srand((unsigned)time(NULL));
    return m+(rand()%(n-m+1));
}

// 取出三个数的中间数（第二大的数)的函数
inline int MidNum(int a,int b,int c){
	if(c<b) Swap(c,b);
	if(b<a) Swap(b,a); // 经过这两个交换，a变成三数最小的
	return b<c?b:c;
}

int ThreeOne_Partition(int *A,int p,int r){
	int i,j,k,mid;
	
	// 随机选择三个数
	i=Random(p,r);
	j=Random(p,r);
	k=Random(p,r);

	// 取出“中间数”
	mid=MidNum(A[i],A[j],A[k]);
	
	// 将“中间数”和A【r】交换
	if(A[i]==mid) Swap(A[i],A[r]);
	else if(A[j]==mid) Swap(A[j],A[r]);
	else if(A[k]==mid) Swap(A[k],A[r]);

	return Partition(A,p,r);
}

void Final_QuickSort(int *A,int p,int r){
	while(p<r){
		int q=ThreeOne_Partition(A,p,r);
		if(q-p<r-q){
			Final_QuickSort(A,p,q-1);
			p=q+1;
		}
		else{
			Final_QuickSort(A,q+1,r);
			r=q-1;
		}
	}
}

int main()
{
    int arr[12]={2,7,4,9,8,5,7,8,2,0,7,-4};
    Final_QuickSort(arr,0,11);
    for(int i=0; i<12; ++i)
        printf("%d ",arr[i]);
    putchar('\n');
    return 0;
}

除此之外，快排还可以有优化：

非递归的方法：即模拟递归，这样可以完全消去递归的调用。

三划分快速排序：基本思想是，在划分阶段以V=A[r]为基准，将带排序数组A【p..r】划分为左、中、右三段A【p,j】,

A【j+1..q-1】,A【q..r】，其中左段数组元素值小于V，中断数组等于V，有段数组元素大于Ｖ。其后，算法对左右

两段数组递归排序。这个方法对于有大量相同数据的数组排序效率有很大的提高，即使没有大量相同元素，也不

降低原快排算法的效率。

以上两种以后有机会再把代码实现一遍吧。

快速排序的总结到这里结束。

目前主要总结了五大排序，都是基于比较的排序，最快也只有O(n lg n)。有没有更快的？

下一篇将总结线性时间排序，其速度将会突破这个瓶颈。

本文参考：http://blog.csdn.net/shuangde800/article/details/7599509

--本人不才，如有疏漏，敬请补充完善！

算法导论：快速排序优化算法！

猜你喜欢