八大排序之快速排序以及优化（5）

快速排序

快速排序是一个在大多数情况下排序性能最好的一个算法，通常情况下，数据规模越大，数据越乱，快速排序的性能越好。下面将说明快速排序具体实现进行说明，并对其进行优化。

快速排序递归形式

算法步骤

快速排序算法通过多次比较和交换来实现排序，其步骤如下：

1. 首先设定一个分界值，通过该分界值将数组分成左右两个部分。（通过将分界值为数组的第一个元素）
2. 将大于或者等于分界值的数据集集中到数组右边，小于分界值的数据集中到数组的左边，此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或者等于分界值。
3. 然后，将左边和右边的数据进行独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置最小值，右边放置较大值。 右侧的数组数据也可以做类似处理。
4. 重复上述过程，通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序排序完成后，所有数据排序完成。

具体示例如下：有以下这一组数据，进行上述操作

代码实现

int Partition(int* arr, int left, int right)  //一次划分函数  核心函数  返回基准值所在下标
{
	//先将arr数组中的第一个注作为基准值
	int tmp = arr[left];
	while (left < right)
	{
		while (left<right && arr[right]>tmp)  //左边边界没有相遇，且当前右边值大
		{
			right--;
		}
		if (left < right) //如果此时，左右边界没有相遇，那就只能证明右边找到了一个小于等于基准值的值
		{
			arr[left] = arr[right];
		}
		else
			break;
		while (left < right && arr[left] <= tmp) //左边边界没有相遇，且当前右边值大
		{
			left++;
		}
		if (left < right) //如果此时，左右边界没有相遇，那就只能证明左边left找到了一个小于等于基准值的值
		{
			arr[right] = arr[left];
		}
		else
			break;
	}
	//此时，因为left等于right
	arr[left] = tmp;
	return left;
}
void Quick(int* arr, int left, int right)
{
	int tmp = 0;
	if (left < right)
	{
		tmp = arr[left];
		int par = Partition(arr, left, right);
		if (left < par - 1) // 至少有两个值才需要递归
		{			
			Quick(arr, left, par - 1);
		}
		if (par + 1 < right)
		{			
			Quick(arr, par + 1, right);
		}
	}
}
void QuickSort(int* arr, int len)
{
	Quick(arr, 0, len - 1);
}

测试结果

算法复杂度分析

时间复杂度：$O(n\ast logn)$，一共有$n$个数据，对$n$个数据进行划分的时候构成一颗递归树，一共需要对$n$个数据进行划分，则需要的时间复杂度为$O(n)$,递归树的高度为$O(logn)$,因此为
$O(n\ast logn)$。
空间复杂度：$O(logn)$，快速排序没有占有额外的空间，它的空间复杂度取决于递归的次数。为$O(logn)$。
并且，快速排序是一个不稳定的排序算法，它的特点是数据越乱，排序越快。

快速排序非递归形式

如果数据量过大，采用快速排序的递归算法会因为栈空间不足导致栈溢出问题，因此需要采取非递归的形式从堆区开辟空间，这里我们将借助栈来模拟递归来实现快速排序的非递归写法

算法优化

优化方法

• 如果数据量过小，那么可以选择直接插入排序比较好
• 由于快排是数据越乱那么其算法效率越高，那么我们采取三数取中法来使得数据变乱（取第一个值，中间位置的值，最后的值，最终调整之后，让不大不小的那个值在开始位置即可）

程序实现

//三数取中法
void Three_Mid(int *arr, int left, int mid, int right)
{
	if(arr[mid] > arr[right])//保证中间值小于右边的值
	{
		int tmp = arr[mid];
		arr[mid] = arr[right];
		arr[right] = tmp;
	}
	if(arr[mid] > arr[left])//保证中间的值 一定是三个数的最小值
	{
		int tmp = arr[mid];
		arr[mid] = arr[left];
		arr[left] = tmp;
	}
	//此时 那个不大不小的值  要么在左边，要么在右边
	if(arr[left] > arr[right])
	{
		int tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
	}
	//此时  不大不小的值就在arr的left位置了

}

//快速排序的非递归写法
void Quick_Stack(int *arr, int left, int right)
{
	LStack st;
	Init_LStack(&st);
	if(left < right)
	{
		int par = Partition(arr, left, right);
		if(left < par-1)
		{
			Push(&st, left);
			Push(&st, par-1);
		}
		if(par+1 < right)
		{
			Push(&st, par+1);
			Push(&st, right);
		}
	}


	while(!IsEmpty(&st))
	{
		int p;
		int q;
		Pop(&st, &q);
		Pop(&st, &p);

		int par = Partition(arr, p, q);
		if(p < par-1)
		{
			Push(&st, p);
			Push(&st, par-1);
		}

		if(par+1 < q)
		{
			Push(&st, par+1);
			Push(&st, q);
		}
	}

}