快排的递归实现

快速排序是一种时间复杂度低，但会虽随着数组的顺序变化，因为其效率之高被称为快速排序，而

且其不稳定性也可以同过优化进行解决。

快速排序的实现有三种方法：

1.hoare版

其基本思想为：任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成

两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右

子序列重复该过程，直到所有元素都排列在相应位置上为止。

实现方法如图：

这幅图是将最左端的元素定为基准值， 先让基准值的另一边（right）开始走，找到比基准值小的

元素时停下，再让基准值（left）这一边开始走，找到比基准值大的元素停下，再将right和left对应

的元素进行交换，重复上述操作。如下图：

第一次交换：

第二次交换：

第二次交换后，right先走后left与right相遇，将相遇的位置的元素与key的元素进行交换，此时

key的元素到了其排序好的最终元素的位置。 如下图：

这就是快速排序的单趟排序， 从上述图可以看出key将这个数组分为两部分，而左边和右边有可以

看为一个新的要排序的数组，而这又可以引用单趟排序，从而构成递归。

那么递归结束的条件是什么呢？是当（left == right）的时候吗？

当要拍序的数组本身有序的时候，我们会发现，可能会存在（left > right），所以递归结束的条件

应该为（left >= right）。

整体的代码如下：

//hoare法
int PartSort1(int* a, int left, int right)
{
	
	随机选k
	//int randi = left + (rand() % (right - left));
	//int key = left;
	//三数取中法
	int mid = FindMidNumi(a, left, right);
	if (mid != left)
	{
		Swap(&a[mid], &a[left]);
	}
	int key = left;

	while (left < right)
	{
		//右边找小
		while (left < right && a[right] >= a[key])
		{
			right--;
		}
		//左边找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}

		Swap(&a[right], &a[left]);
	}
	Swap(&a[key], &a[right]);
	key = right;

	return key;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	
	int key = PartSort1(a, left, right);
	QuickSort(a, left, key - 1);
	QuickSort(a, key + 1, right);
	
}

2.挖坑法

此方法是hoare的一种变形，与上面的方法十分类似。

同样，我们把最左边的元素设为基准值，并将元素挖出来，用局部变量key将其存储如下图：

之后也是从右边先找到比key小的元素，并将此元素与坑位进行交换：

在从左边开始找比key大的元素，将其与坑位交换：

直到left与right相遇， 将key的值填回坑位。

从上述图可以看出key将这个数组分为两部分，而左边和右边有可以看为一个新的要排序的数组，

而这又可以引用单趟排序，从而构成递归。

 递归结束条件为：（left >= right）。

 代码如下：

//挖坑法
int PartSort2(int* a, int left, int right)
{
	//三数取中法
	int mid = FindMidNumi(a, left, right);
	if (mid != left)
	{
		Swap(&a[mid], &a[left]);
	}
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		//右边找小
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		//左边找大
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;

	}
	a[hole] = key;

	return hole;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	
	int key = PartSort2(a, left, right);
	QuickSort(a, left, key - 1);
	QuickSort(a, key + 1, right);
	
}

3.前后指针法：

前后指针法是快排的一种进阶方法：

分为两个指针：一个是当前位置（cur）一个是前一个位置（prev），其排序方法如下：

同样，我们把最左边的元素设为基准值

1，如果cur的值比key小，++prev，并将cur1的元素和prev的元素进行交换，++cur。

2，如果cur的值比key大，++cur。

3，当cur超过数组范围后，将prev的值和key交换。

从上述图可以看出key将这个数组分为两部分，而左边和右边有可以看为一个新的要排序的数组，

而这又可以引用单趟排序，从而构成递归。

 递归结束条件为：（left >= right）。

代码如下：

int PartSort3(int* a, int left, int right)
{
	// 三数取中法
	int mid = FindMidNumi(a, left, right);
	if (mid != left)
	{
		Swap(&a[mid], &a[left]);
	}
	int keyi = left;
	int prev = left;
	int cur = left + 1;
	/*while (cur <= right)
	{
		if (a[cur] < a[keyi])
		{
			++prev;
			Swap(&a[cur], &a[prev]);
			++cur;
		}
		else
		{
			++cur;
		}
	}*/
	//更简明，但是不好懂
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	Swap(&a[prev], &a[keyi]);
	keyi = prev;

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	
	int key = PartSort3(a, left, right);
	QuickSort(a, left, key - 1);
	QuickSort(a, key + 1, right);
	
}

我们刚开始提到时间复杂度随着数组的顺序变化，是因为当快速排序排有序的数组时，应为本身

就在最终位置，所以导致快排需要将所有元素都遍历一遍，从而使时间复杂度升高，而我们的解

决办法是三数取中法：

取数组最左，最右，中间三个元素来进行比较，取出最中间的元素，将其与最左边的元素进行交

换，从而使key的值在数组中处在一个居中的位置，代码如下（前面的代码都加了三数取中法）：

//三数取中法
int FindMidNumi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

这样就可以让快排的时间复杂度稳定在O（n*logn）了，快排还是有些难度的，不过上述方法大家

可以只掌握一种，会写出快速排序即可。