【数据结构与算法】快速排序的三种实现方法

最新推荐文章于 2024-08-13 09:00:00 发布

nagiY

最新推荐文章于 2024-08-13 09:00:00 发布

阅读量1.1k

点赞数 52

分类专栏：数据结构与算法文章标签：排序算法算法数据结构 c语言

本文链接：https://blog.csdn.net/m0_73868817/article/details/130000934

版权

数据结构与算法专栏收录该内容

11 篇文章 5 订阅

订阅专栏

一.基本思想

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

二.Hoare法

假设我们让最左边为keyi（注意这个表示的是下标），且要排升序；

1.若最左边为keyi，则right先走，找比arr[keyi]小的，left后走，找比arr[keyi]大的，然后right与left交换；

当left和right相遇时，结束循环，最后交换arr[keyi]和arr[left]；

再让keyi=left，接着递归它的左子列和右子列；

2.若最右边为keyi，则left先走，找比arr[keyi]大的，right后走，找比arr[keyi]小的，然后right与left交换；

当left和right相遇时，结束循环，最后交换arr[keyi]和arr[left]；

再让keyi=right，接着递归它的左子列和右子列；

注意这里的keyi，left，right都是下标。

左子列的区间是begin到keyi-1；

右子列的区间是keyi+1到end；

动态演示

void QuickSort(int* arr, int left,int right)
{
	
	if (left >= right)
		return;
	int begain = left;
	int end = right;
	int keyi= left;
	while (left < right)
	{
        //这里要先判断left<right，防止越界，下同
		while (left<right && arr[right]>=arr[keyi])   //找小
		{
			right--;
		}

		while (left < right && arr[left] <= arr[keyi])  //找大
		{
			left++;
		}

		Swap(&arr[left], &arr[right]);   //交换
	}

	Swap(&arr[keyi], &arr[left]);
	keyi = left;

	QuickSort(arr, begain, keyi-1);   //递归左子列
	QuickSort(arr, keyi+1, end);      //递归右子列
}

三.挖坑法

动态演示

上面的Hoare法有很多坑，一不注意就容易写错，而挖坑法就没那么多坑了。

这个方法需要定义一个坑变量（hole），前面的Hoare法是交换两个元素，挖坑法是把值赋给坑位，然后更新一下坑位。

void QuickSort(int* arr, int left, int right)
{

	if (left >= right)
		return;
	int begain = left;
	int end = right;
	int keyi = left;
	int hole = left;   //坑变量
	while (left < right)
	{
		while (left < right && arr[right] >= arr[leyi])   //找小
		{
			right--;
		}
		arr[hole] = arr[right];   //赋值给坑位
		hole = right;   //更新坑位
		while (left < right && arr[left] <= arr[keyi])   //找大
		{
			left++;
		}

		arr[hole] = arr[left];
		hole = left;
	}

	arr[hole] = key;
	keyi = left;
    //递归左右子列
	QuickSort(arr, begain, hole - 1);
	QuickSort(arr, hole + 1, end);
}

四.前后指针法

动态演示

这个方法可以说是实现快速排序最常用的方法了。

1.定义一个prev和cur，它们都表示数组的下标，当然你定义成指针也没问题，这里以下标为例；

2.cur=prev+1

注意：

a.prev要么紧跟着cur，即prev的下一个就是cur；

b.prev跟cur中间隔着比key大的一段值区间；

3.cur找到比key小的值，prev++，cur和prev位置互换，cur++；

4.cur找到比key大的值，cur++；

5.当cur>right时结束循环。

void QuickSort(int* arr, int left, int right)
{
	if (left >= right)
		return;
	int begin = left, end = right;
	int prev = left, cur = left + 1;

	int keyi = left;
	while (cur <= right)
	{
		if (arr[cur] < arr[keyi])   
		{
			prev++;
			Swap(&arr[cur], &arr[prev]);
			cur++;
		}

		while (arr[cur] > arr[keyi])
		{
			cur++;
		}
	}
	Swap(&arr[keyi], &arr[prev]);
	keyi = prev;
	QuickSort(arr, begin, keyi - 1);
	QuickSort(arr, keyi + 1, end);
}

五.快速排序优化

在面对有序或是接近有序的情况下，快速排序的效率不高，是O(N^2)，那要怎么解决这个问题呢？

既然对有序或是接近有序的不行，那我们就打乱它的顺序，这里有两种方法：

1.通过生成区间内的随机下标，让keyi与randi的数据交换，这样就打乱了原来的顺序；

2.三路取中法。

随机下标交换法

int randi = left + rand() % (right - left);   //随机key
Swap(&arr[keyi], &arr[randi]);

三路取中法

int GetMid(Sdatatype* arr, int left, int right)
{
	int mid = (left + right) / 2;
	if (arr[left] < arr[mid])
	{
		if (arr[mid] < arr[right])
			return mid;
		else if (arr[right] < arr[left])
			return left;
		else
			return right;
	}
	else  //arr[left]>arr[mid]
	{
		if (arr[right] < arr[mid])
			return mid;
		else if (arr[right] > arr[left])
			return left;
		else
			return right;

	}

}

	if (left != midi)
		Swap(&arr[left], &arr[midi]);