前面我们已经了解了几大排序了，那么我们今天就来再了解一下剩下的快速排序法，这是一种非常经典的方法，时间复杂度是N*logN。

快速排序法：

基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

我们的快速排序可以通过递归和非递归来实现，我们先来看看递归实现快排，我们的递归快排又分为三个版本，三种方法各有各的特点，我们接下来就来看看吧。

需要调用的函数代码：

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	// begin midi end 三个数选中位数
	if (a[begin] < a[midi])
	{
		if (a[midi] < a[end])
			return midi;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else // a[begin] > a[midi]
	{
		if (a[midi] > a[end])
			return midi;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}

hoare版本单趟排序：

// hoare
int PartSort1(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int left = begin, 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;
}

这个版本的单趟排序理解起来很容易，但是我们的坑点比较多，所以难度对于我们而言还是有点挑战性，我们需要两个变量来实现，我们的left从左边数组的首元素开始走，找比keyi位置大的元素，keyi代表的就是我们数组首元素的下标，我们用right从最后一个元素开始走，找比keyi位置小的元素，找到了一个大的元素和一个小的元素就交换，但是我们的数组中可能有多个相等的元素，所以我们内嵌循环就得用<=。我们最后left和right相遇时结束，相遇位置的右边的元素大于等于keyi位置的元素，而相遇位置左边的元素都小于等于keyi位置的元素，我们最后就将left位置的元素和keyi位置的元素交换再返回left就完成了。

挖坑法单趟排序：

int PartSort2(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int key = a[begin];
	int hole = begin;
	while (begin < end)
	{
		// 右边找小，填到左边的坑
		while (begin < end && a[end] >= key)
		{
			--end;
		}

		a[hole] = a[end];
		hole = end;

		// 左边找大，填到右边的坑
		while (begin < end && a[begin] <= key)
		{
			++begin;
		}

		a[hole] = a[begin];
		hole = begin;
	}

	a[hole] = key;
	return hole;
}

我们先将第一个数据存放在临时变量key中形成一个坑位，我们同样用到left和right，同样的用法，left从第一个元素往后走，right从最后一个元素往前走。我们的right先走，找到一个比hole下标小的元素就于hole下标的元素交换，交换之后left再走，找到一个比hole位置大的元素就与hole位置的元素交换，然后再left位置形成一个坑点。然后又是right走，交换后left走，反复进行，最后在相遇的时候就结束循环。因为我们的hole下标的值都是空的，所以在最后我们将key的数据给hole下标的坑位就可以了，最后再返回坑位的数据。具体的过程如下图所示：

前后指针版本单趟排序：

int PartSort3(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);
	int keyi = begin;

	int prev = begin;
	int cur = prev + 1;
	while (cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[prev], &a[cur]);

		++cur;
	}

	Swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}

我们的前后指针版本看起来比前两个版本更加的容易，因为我们的两个指针prev指向我们数组首元素的下标，而cur是我们首元素的下一个元素的下标，我们的cur先走，如果我们指向的元素比keyi位置的元素大的话我们就cur++向前走一位，如果比keyi位置的元素小的话我们就prev++向前走一位再与cur位置的交换，cur再继续往前走知道cur>end的时候就结束循环。最后我们再将prev位置的数据给keyi位置就完成了。

单趟优化版本：

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	if (end - begin + 1 <= 10)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int midi = GetMidi(a, begin, end);
		Swap(&a[midi], &a[begin]);

		int left = begin, 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]);
		keyi = left;

		// [begin, keyi-1] keyi [keyi+1, end]
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

单趟优化版本就是我们的区间数据不大时，我们用直接插入排序法，而数据太大的时候我们就用hoare版本的单趟排序。

函数递归实现快排：

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort2(a, begin, end);
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

实现我们只需要调用一个版本的单趟排序在进行递归就可以了。我们代码中是用的挖坑法的单趟排序，我们就直接调用PartSort2就可以了。

递归的我们已经了解完了，那么我们就来看看非递归的怎么实现吧：

void QuickSortNonR(int* a, int begin, int end)
{
	ST s;
	STInit(&s);
	STPush(&s, end);
	STPush(&s, begin);

	while (!STEmpty(&s))
	{
		int left = STTop(&s);
		STPop(&s);
		int right = STTop(&s);
		STPop(&s);

		int keyi = PartSort3(a, left, right);
		// [left, keyi-1] keyi [keyi+1, right]
		if (left < keyi - 1)
		{
			STPush(&s, keyi - 1);
			STPush(&s, left);
		}

		if (keyi + 1 < right)
		{
			STPush(&s, right);
			STPush(&s, keyi + 1);
		}
	}

	STDestroy(&s);
}

非递归版本的快速排序。我们需要起始位置 begin 和结束位置 end。首先，函数创建一个栈 st，用于存储待处理的子数组的起始和结束位置。将 end 和 begin 分别压入栈中，表示对整个数组进行排序。进入循环，只要栈不为空，从栈中弹出两个元素，分别赋值给 left 和 right，表示当前要处理的子数组的起始和结束位置。调用 PartSort3 函数对子数组进行分区，得到基准元素的位置 keyi。根据分区的结果，将子数组划分为 [left, keyi-1]、[keyi]、[keyi+1, right] 三个部分。如果 keyi + 1 < right，说明右侧子数组仍然有元素需要排序，将右侧子数组的起始位置 keyi + 1 和结束位置 right 压入栈中。如果 left < keyi - 1，说明左侧子数组仍然有元素需要排序，将左侧子数组的起始位置 left 和结束位置 keyi - 1 压入栈中。循环继续进行，直到栈为空，表示所有子数组都被处理完毕。最后，销毁栈 st，就完成了非递归版本的快速排序。

如果对大家有所帮助的话就支持一下吧！