数据结构之排序（八）——快速排序

快速排序（Quick Sort）的基本思想是：通过一趟排序将待排记录分割成独立的俩部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这俩部分记录继续进行排序，以达到整个序列有序的目的。

原理

先选取当中的一个关键字，将它放到一个位置，使得它的左边的值都比它小，右边的值比它它，我们将这样的关键字称为枢轴（pivot），然后对左右俩部分分别进行同样的操作，直到顺序全部正确为止。

算法

#include "stdafx.h"
using namespace std;
#include
#include"stdafx.h"
//用于要排序数组个数最大值，可根据需要修改  
#define MAXSIZE 10  
typedef struct
{
	//用于存储要排序数组，r[0]用作哨兵或临时变量  
	int r[MAXSIZE + 1];
	//用于记录顺序表的长度  
	int length;
}SqList;
//交换L中数组r的下标为i和j的值  
void swap(SqList *L, int i, int j) {
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}


/* 交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置 */
/* 此时在它之前(后)的记录均不大(小)于它。 */
int Partition(SqList *L, int low, int high)
{
	int pivotkey;

	pivotkey = L->r[low]; /* 用子表的第一个记录作枢轴记录 */
	while (lowr[high] >= pivotkey)
			high--;
		swap(L, low, high);/* 将比枢轴记录小的记录交换到低端 */
		while (lowr[low] <= pivotkey)
			low++;
		swap(L, low, high);/* 将比枢轴记录大的记录交换到高端 */
	}
	return low; /* 返回枢轴所在位置 */
}

/* 对顺序表L中的子序列L->r[low..high]作快速排序 */
void QSort(SqList *L, int low, int high)
{
	int pivot;
	if (lowr[low..high]一分为二，算出枢轴值pivot */
		QSort(L, low, pivot - 1);		/*  对低子表递归排序 */
		QSort(L, pivot + 1, high);		/*  对高子表递归排序 */
	}
}

/* 对顺序表L作快速排序 */
void QuickSort(SqList *L)
{
	QSort(L, 1, L->length);
}

#define N 9
int main()
{
	int d[N] = {50,10,90,30,70,40,80,60,20};
	SqList L0;
	for (int i = 0; i 

运行结果

算法复杂度分析

快速排序的时间复杂度为：O（nlogn）

算法稳定性

不稳定

快速排序优化

1.优化选取枢轴

随机选取枢轴法

随机获得一个low与high之间的数rnd，让它的关键字L.r[rnd]与L.r[low]交换，此时就不容易出现这样的情况。

三数取中法（median-of-three）

取三个关键字先进行排序将中间数作为枢轴，一般是取左端，右端和中间三个数，也可以随机选取。代码如下：

int Partition(SqList *L, int low, int high)
{
	int m = low + (high - low) / 2; /* 计算数组中间的元素的下标 */
	if (L->r[low]>L->r[high])
		swap(L, low, high);	/* 交换左端与右端数据，保证左端较小 */
	if (L->r[m]>L->r[high])
		swap(L, high, m);		/* 交换中间与右端数据，保证中间较小 */
	if (L->r[m]>L->r[low])
		swap(L, m, low);		/* 交换中间与左端数据，保证左端较小 */

	int pivotkey;

	pivotkey = L->r[low]; /* 用子表的第一个记录作枢轴记录 */
	while (lowr[high] >= pivotkey)
			high--;
		swap(L, low, high);/* 将比枢轴记录小的记录交换到低端 */
		while (lowr[low] <= pivotkey)
			low++;
		swap(L, low, high);/* 将比枢轴记录大的记录交换到高端 */
	}
	return low; /* 返回枢轴所在位置 */
}

对于非常大的待排序的序列可以选择九数取中（median-of-nine），它先从数组中分三次取样，每次取三个数，三个样品各取出中数，然后从这三个中数再取出一个中数作为枢轴。

2.优化不必要的交换

代码如下：

int Partition(SqList *L, int low, int high)
{
	int pivotkey;

	int m = low + (high - low) / 2; /* 计算数组中间的元素的下标 */
	if (L->r[low]>L->r[high])
		swap(L, low, high);	/* 交换左端与右端数据，保证左端较小 */
	if (L->r[m]>L->r[high])
		swap(L, high, m);		/* 交换中间与右端数据，保证中间较小 */
	if (L->r[m]>L->r[low])
		swap(L, m, low);		/* 交换中间与左端数据，保证左端较小 */
	pivotkey = L->r[low]; /* 用子表的第一个记录作枢轴记录 */
	L->r[0] = pivotkey;  /* 将枢轴关键字备份到L->r[0] */
	while (lowr[high] >= pivotkey)
			high--;
		L->r[low] = L->r[high];
		while (lowr[low] <= pivotkey)
			low++;
		L->r[high] = L->r[low];
	}
	L->r[low] = L->r[0];
	return low; /* 返回枢轴所在位置 */
}

3.优化小数组时的排序方案

我们增加一个判断，当high-low不大于某个常数时，就直接用插入排序，这样就可以保证最大化地利用俩种排序的优势来完成排序工作。

代码如下：

* 用于快速排序时判断是否选用插入排序阙值 */
#define MAX_LENGTH_INSERT_SORT 7 
void QSort(SqList *L, int low, int high)
{
	int pivot;
	//当high-low大于常数时用快速排序
	if ((high-low)>MAX_LENGTH_INSERT_SORT)
	{
		pivot = Partition(L, low, high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
		QSort(L, low, pivot - 1);		/*  对低子表递归排序 */
		QSort(L, pivot + 1, high);		/*  对高子表递归排序 */
	}
	else {
		//当high-low小于常数时用直接插入排序
		InsertSort(L);
	}
}

直接插入排序，代码如下：

/* 对顺序表L作直接插入排序 */
void InsertSort(SqList *L)
{ 
	int i,j;
	for(i=2;i<=L->length;i++)
	{
		if (L->r[i]r[i-1]) /* 需将L->r[i]插入有序子表 */
		{
			L->r[0]=L->r[i]; /* 设置哨兵 */
			for(j=i-1;L->r[j]>L->r[0];j--)
				L->r[j+1]=L->r[j]; /* 记录后移 */
			L->r[j+1]=L->r[0]; /* 插入到正确位置 */
		}
	}
}

4.优化归并操作

对QSort实施尾递归优化。

代码如下：

/* 用于快速排序时判断是否选用插入排序阙值 */
#define MAX_LENGTH_INSERT_SORT 7 
void QSort(SqList *L,int low,int high)
{ 
	int pivot;
	if((high-low)>MAX_LENGTH_INSERT_SORT)
	{
		while(lowr[low..high]一分为二，算出枢轴值pivot */
			QSort1(L,low,pivot-1);		/*  对低子表递归排序 */
			/* QSort(L,pivot+1,high);		/*  对高子表递归排序 */
			low=pivot+1;	/* 尾递归 */
		}
	}
	else
		InsertSort(L);
}