欢迎各位大佬光临本文章！！！

还请各位大佬提出宝贵的意见，如发现文章错误请联系冰冰，冰冰一定会虚心接受，及时改正。

本系列文章为冰冰学习编程的学习笔记，如果对您也有帮助，还请各位大佬、帅哥、美女点点支持，您的每一分关心都是我坚持的动力。

我的博客地址：bingbing~bang的博客_CSDN博客https://blog.csdn.net/bingbing_bang?type=blog

我的gitee：冰冰棒 (bingbingsupercool) - Gitee.comhttps://gitee.com/bingbingsurercool

---

系列文章推荐

冰冰学习笔记：循环队列的实现

冰冰学习笔记：常见的几种排序算法

---

目录

系列文章推荐

前言

一、快速排序的思想

二、快速排序的递归实现

2.1快速排序的单趟实现

2.1.1hoare法（左右交换）

2.1.2挖坑法 

2.1.3前后指针法

2.2快速排序的整体实现

2.3快速排序的优化

2.3.1快速排序的性能

2.3.2三数取中优化

2.3.3小区间优化

三、快速排序的非递归实现

总结

---

前言

        前面的文章介绍了几种排序算法的实现，堆排序与希尔排序的效率都是相当优秀，那有没有一种排序比这两个还要强呢？答案是有的，这种排序就是快速排序。下面我们来看看该种算法的实现。

一、快速排序的思想

        快速排序的实现方式有两种，递归与非递归，两种方式都需要掌握。

二、快速排序的递归实现

        递归实现快速排序是最常用的方式，也Hoare提出时使用的方式，当进行单趟排序后，会将一个数据的位置排好，此时我们就可以使用递归将排好数据位置的左区间和右区间继续进行排序。有些人会担忧递归方式实现会不会出现栈溢出的情况，确实有可能出现。但是通常情况下是不会出现的，如果每次基准值取折中处，10亿个数递归深度才30次左右，因此基本不会栈溢出。要想完全分析清楚快速排序，就得理解单趟排序的实现。

2.1快速排序的单趟实现

2.1.1hoare法（左右交换）

        该种方式就是Hoare大佬提出的方式，下面动图为单趟排序的逻辑。

        首先我们先找取一个值作为比对的基准值，这里选数组左右开头元素都可以，但是要注意如果选取左边作为基准值，那就得让右边先走，反之亦然。 其基本步骤为：先选取数组左边元素作为基准值key，左右下标分别指向数组开头与结尾。右边先走，找到比key小的值停下；然后左边再走，找到比key大的值停下，然后交换两者指向的值，循环往复直到二者相遇停止。停止后，将相遇处的值与key指向的值进行交换，此时key指向的基准值将正确的排列到数组的位置中。

        那为什么左边做基准值，右边先走呢？我们可以看到在单趟排序过程中，单趟排序的最后一步是将左右指针相遇位置的值与key指向的值进行交换，如果key为左边选取的基准值，那么相遇位置的值只有保证比key小才能满足交换后，左边的所有值都小于key，右边所有值都大于key。在左边做基准值的时候，右边指针用来寻找比基准值小的值，因此如果是右边先走，找到小的值停下来，然后左边再走，左边遇到了右边停下来，此时停下的位置为右边先前找到的小值而停下的位置，所以交换后也满足条件。另一种情况是右边出发去寻找小于key的值，结果碰到了左边，那么就说明相遇位置后面的所有值都比key大，此时左边指向的位置要么为上一轮停下的位置，要么左边还没出发，指向的就是key，依然是符合小于等于key，那么交换后还是满足条件。如果是左边做基准值，左边先走将会导致停下来时指向的值有可能为大于key的值，交换后不符合排序思想。

如果左边先走，将会出现下图状况：

        所以我们在此种方式下，必须让右边先走。因此我们的单趟排序实现原理如下：首先使用begin作为排序数组的起始位置下标，end为排序数组末尾位置下标。用left为指向左移动下标，right为右移动下标，key为基准值下标，这里用begin指向的数值作为基准值。然后进入循环，先让右边先走，找小，然后左边再走，找大。两边都找到后进行交换，寻找过程中如果两者相遇直接停止寻找，跳出循环进行数据交换，最后返回找到排列好的数据的下标，方便分割区间。

hoare法单趟排序：

int PartSort1(int* a, int begin, int end)
{
	int left = begin;
	int right = end;
	int keyi = begin;
	while (left < right )
	{
		//从后往前找小
		while (left<right && a[right] >= a[keyi] )
		{
			right--;
		}
		//从前往后找大
		while ( left < right && a[left] <= a[keyi] )
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[keyi]);
	return left;//返回排列完成后数据的下标

        这里要注意，while的循环条件为继续的条件，right找小，因此条件应为大于等于。如忽略等于符号，将会出现死循环。 

2.1.2挖坑法 

        挖坑法的思想是基于hoare法实现的，下面动图为挖坑法的单趟实现：

        其基本思想为：选取左边作为基准值，将其保存到临时变量key中，那么左边第一个位置相当于空出一个位置，那么我们就从右边寻找比key小的值来填补这个坑位，右边找到后，将右边指向的数据填补到左边的坑位中，此时右边指向的位置就空出来了，然后左边寻找比key大的值，找到后将其填补到坑位中。若在寻找过程中两者相遇，则将key的值放置到坑位中即可。

        因此挖坑法与hoare法并没有本质区别，但是二者单趟排序后有可能数组中数据位置不一样，还是需要了解。

        挖坑法比Hoare法好理解的地方就是哪边有坑，我就从另一边寻找值来填补，最后再把最开始的坑填上即可。 

挖坑法单趟排序：

int PartSort2(int* a, int begin, int end)
{
	DataType key = a[begin];
	int piti = begin;//坑位
	int right = end;
	int left = begin;
	while ( left < right )
	{
		//右边找小，填左坑
		while ( left < right &&a[right] >= key )
		{
			right--;
		}
		Swap(&a[piti], &a[right]); 
		piti = right;
		//左边找大，填右坑
		while ( left < right && a[left] <= key )
		{
			left++;
		}
		Swap(&a[piti], &a[left]);
		piti = left;
	}
	Swap(&key, &a[piti]);
	return piti;
}

2.1.3前后指针法

        前后指针法是对Hoare法和挖坑法的再一次更新，此种方式完全摒弃了左右指针寻找值的方式，使其更加容易理解，下图为双指针方式动图：

        该方法的主要思想是利用两个前后指针cur和prev，开始时，prev与key均指向待排数组的第一个数据，然后cur指向第二个数据，cur一直向后移动，遇到比key小的数时停下，与prev指向的前一个数据进行交换，当cur走出数组下标范围后，循环停止，然后再将key指向的数据与prev指向的数据进行交换，完成单趟排序。

        为什么此种方式可以完成单趟排序呢？如果key后面的数据全是比key小的值，那么，cur与prev的后一个位置永远指向的是同一个数据，交换后不变，等cur走出下标范围时，prev正好指向最后一个数据的位置，此时将key与其交换，key移动到数组最后面，也完成了单趟排序。即便key后面全是大于key的值，cur将一直向后移动，走出范围后停止，prev指向的与key指向的位置相同，因此照样符合条件。只要key后面存在大于key指向位置数据的值，cur与prev将会拉开差距，二者之间均为大于key位置指向的数据的值，因此当cur找到小于基准值的时候，prev后面的位置一定是大于key位置数据的，二者交换意味着将小值放到前面，大值放到后面。

        我们发现上述过程中cur一直在移动，只有当其出了边界才会停止循环，因此我们仅需要一个循环即可。并且若prev+1后于cur相等，此时的交换是没有意义的，因此可以增加判断条件来避免此种状况。

双指针单趟排序：

int PartSort3(int* a, int begin, int end)
{
	int key = begin;
	int cur = begin + 1;
	int prev = begin;
	while ( cur <= end )
	{
		if ( (a[cur] < a[key])&&(++prev!= cur) )
		{
			Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	Swap(&a[prev], &a[key]);
	return prev;
}

2.2快速排序的整体实现

        实现了上述三种单趟排序后，剩下的就是快排的整体实现方式，前面说了，快排的递归实现方式是最经典的也是最常用的，因此我们就得划分出递归区间。我们知道在实现单趟递归后，key所指向的值是排列到正确的位置了，因此begin到key-1，与key+1到end这两个区间是未排序的，因此这两个区间是需要递归来排序的。那递归结束的条件是什么呢？如果一个数组中只有一个数据或者没有数据，那么就是有序的，所以递归停止的条件是区间不存在begin>end，或者只有一个值begin=end。

因此最终的快排递归程序代码为：

void QuickSort(DataType* pa, int begin, int end)
{
	assert(pa);
	if ( begin >= end )
	{
		return;
	}
	//这里为单趟实现的方式
	int keyi = PartSort1(pa, begin, end);
 
	QuickSort(pa, begin, keyi - 1);
	QuickSort(pa, keyi + 1, end);
}

2.3快速排序的优化

2.3.1快速排序的性能

        快速排序我们已经能实现了，那么效率究竟如何还得实践来检验，下面为对快排，希尔，堆排序进行数据测试的结果：

         快排的表现还是非常完美的，理想状态下快排的时间复杂度为O(N*logN)，空间复杂度为O(logN)。但是快排在处理有序或者接近有序数据时表现就没有这么卓越了，甚至出现栈溢出的状况，为什么呢？

对10万有序数据处理结果：

         我们发现快排效率远不及其他排序。

        原因在于key的选取，快排的效率取决于key的选取是否得当，如果每次选取的key均为中间位置的值，那么就是经典的N*logN，如果有序或接近有序状态下，选取的为最小或最大就会造成N^2的时间复杂度。此时效率极大的降低，并且在数据多时会造成栈溢出的现象。

        针对上述状况，有些人提出了优化方式，更改key的选取，使其变为随机数，或者减少递归层数，避免栈溢出。

2.3.2三数取中优化

        三数取中的优化是为了解决key取值的问题提出的，三数取中即在排序数组中key的选取不再是开头位置的值或者结尾位置的值，而是取开头的值，中间的值，末尾的值进行比较，选出三个值中大小适中的值，这样就有效避免了选取的值过大或者过小的问题，即便遇到有序状况，每次选取的都是中间的值，时间复杂度不再是N^2而是N*logN。

        使用三数取中优化并不需要对原有的单趟排序进行更改，由于以前的key选取的位置都是数组开头位置begin，因此我们使用三数取中获得适中值的下标，使用交换函数让其与begin指向的位置进行互换即可。

三数取中函数代码：

int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if ( a[mid] < a[begin] )
	{
		if ( a[begin] < a[end] )//mid<begin<end
		{
			return begin;
		}
		else if ( a[end] < a[mid] )//end<mid<begin
		{
			return mid;
		}
		else//mid<end<begin
		{
			return end;
		}
	}
	else//a[mid]>=a[begin]
	{
		if ( a[mid] < a[end] )//begin<mid<end
		{
			return mid;
		}
		else if ( a[end] < a[begin] )//end<begin<mid
		{
			return begin;
		}
		else//begin<end<mid
			return end;
	}
}

2.3.3小区间优化

        小区间优化是为了解决递归层数过多而提出的一种优化方式，如果一直使用递归来进行排序，当数据量很大时，快排具有明显优势，但是当数据量较少，例如只有10个或者20个数据的时候，使用递归来一层一层进行排序，将会被递归调用很多次，浪费空间时间。在处理数据量很小的排序时，插入排序是非常有效的一种排序，因此小区间优化就是在使用快排排序时，遇到小区间使用插入排序来代替递归，从而达到优化的目的。

下面是对100万个数据进行排序时，递归调用的次数：

        我们可以看到明显的变化，使用小区间对小于20个数据的区间使用插入排序来优化，100万数据大约减少了58%的递归次数。

小区间优化代码：

void QuickSort(DataType* pa, int begin, int end)
{
	assert(pa);
	//count++;
	if ( begin >= end )
	{
		return;
	}
	if ( end - begin > 20 )
	{
		int keyi = PartSort3(pa, begin, end);
		QuickSort(pa, begin, keyi - 1);
		QuickSort(pa, keyi + 1, end);
	}
	else
	{
		InsertSort(pa + begin, end - begin + 1);
	}
}

三、快速排序的非递归实现

        讲解完毕快排的递归实现方式，下面介绍一下快排的非递归实现的方式。为什么要用非递归来实现快速排序呢？道理很简单，只要使用递归来完成的算法都有一个死穴，那就是有栈溢出的风险，因此为了避免这种状况的发生，通常使用非递归来替代。递归改非递归通常有两种办法，一种是用循环来更改，例如斐波那契数列，归并排序；一种是使用数据结构的栈来模拟递归方式，此种情况通常使用在不好改循环的递归算法中。

        快速排序使用的是利用栈来模拟递归过程，由于栈的实现是在堆上面开辟的空间，堆通常情况下足够大，因此不会照成栈溢出的状况。

        快速排序非递归的实现方式：

        首先创建一个栈s，由于栈是先进后出的形式，因此如果要对数据范围begin到end之间进行排序，需要先入end再入begin，这样取出时left获得的就是begin，right获得的就是end。然后进入循环，首先从栈中获得需要排列的左右下标，然后将栈中数据弹出，并对left，right指向的区间进行单趟排序，获取正确排序后key的下标，将区间分为left---key-1，key，key+1---right。然后将新区间范围继续入栈，但并非一直入栈，只有区间当中大于一个元素的时候才会进栈。只要栈中含有数据，就代表还有区间没有排序，因此循环需要继续，当栈为空时，循环停止，排序完成，最后将栈销毁避免内存泄漏。

快速排序非递归实现：

void QuickSortNonR(DataType* pa, int begin, int end)
{
	assert(pa);
	ST s;
	StackInit(&s);
	StackPush(&s, end);
	StackPush(&s, begin);
	while ( !StackEmpty(&s))
	{
		int left = StackTop(&s);
		StackPop(&s);
		int right = StackTop(&s);
		StackPop(&s);
		int key= PartSort3(pa, left, right);
		if ( key + 1 < right )//区间多余1个元素
		{
			StackPush(&s, right);
			StackPush(&s, key + 1);
		}
		if ( left < key - 1 )
		{
			StackPush(&s, key - 1);
			StackPush(&s, left);
		}
	}
	StackDestroy(&s);
}

总结

        快速排序是排序中综合性能最优的排序算法，本文只是对其基本形态进行了讲解，排序算法在生活中随处可见，应用非常广泛，因此是需要掌握的必备算法。在快速排序的非递归实现方式中，我们不仅可以使用栈来模拟，也可以使用队列来模拟实现，只不过用队列进行的排序过程更接近与二叉树中层序遍历的过程。