拒绝水文!八大排序(三)【适合初学者】快速排序

文章目录

  • 快速排序递归实现
    • 霍尔法
      • 优化
    • 挖坑法
    • 前后指针法
  • 快速排序非递归

大家好,我是纪宁,这篇文章将向大家介绍非常有名气的一款排序:快速排序
回忆到我们刚开始学习C语言的时候。经常会使用到一个库函数: qsort函数 ,O(N*logN) 的时间复杂度不知道比冒泡排序强了多少倍,那时候经常会想,我靠,这效率牛。那么这篇文章,就带大家深入理解快排的原理及它的多种实现方式。

时间复杂度:O(N*logN)
空间复杂度:O(1)
稳定性:不稳定

快速排序递归实现

霍尔法

假如现在有一个数组,要对它进行升序排列,那么排好序后,每个数的位置都应该是固定的,快排的思路就是这样:先将一个数作为key(一般选择数组的最左边),然后定义两个指针分别从左右遍历数组(从右边开始),将比 key 大的数全部放在数组偏右边,将比 key 小的数全部放在数组偏左边,然后在两个指针相遇的地方,将这个位置的值与最左边的key 值进行交换,那么key 就放在了正确的位置,即 key 左边全部是小于 key 的,右边全部是大于 key 的数据。
拒绝水文!八大排序(三)【适合初学者】快速排序_第1张图片
结束后,以当前的key 为分界线,key 左边的为一组,右边为一组,再递归重复上面的步骤。

int QuickSortPart(int*a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		while (right > left)
		{
			if (a[right] < a[keyi])
				break;
			right--;
		}
		while (left < right)
		{
			if (a[left] > a[keyi])
				break;
			left++;
		}
		Swap(&a[right], &a[left]);
	}
	Swap(&a[left], &a[keyi]);
	return left;
}
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)//等于是只有一个数需要排,大于是没有数需要排
	{
		return;
	}
	int keyi = QuickSortPart(arr, begin, end);
	QuickSort(arr, begin, keyi - 1);
	QuickSort(arr, keyi + 1, end);
}

代码解释:用 keyi 把 left 表示出来是因为left的值会在调整的过程中改变;函数传参传进 QuickSort 的部分是数组首元素的下标和数组最后一个数据的下标;当递归再次进入函数 QuickSort 的时候,如果begin>=end,说明某一边已经没有元素要排或者只有一个元素不用排。

优化

优化1:三数取中
理想情况下,每次将数组二分。每次遍历数组的时间复杂度为O(N),二分的时间复杂度为O(logN),所以这个过程下来,时间复杂度就是O(logN)

但如果情况不理想呢?假如数组已经接近有序的状态了,且第一个数是最小值,那么在右边根本找不到比它小的,一直左移,最后就只能将第一个数确定位置,如此往复,那么分割的时候也要分割N次,时间复杂度瞬间就变成了(N^2)。
改进方法:在QuickSortPart函数实现中添加一个三数取中函数,实现一个找最开始、中间、最后面三个数中最大值的功能,然后将这个数与 left 对应的值进行交换。这样,最左边就变成了偏中间的值,那么就可以做到将数组分割的更好。

优化2:小区间优化
当区间比较小的时候,继续使用递归显然是不太合适的,递归太深的话函数栈帧的压力是非常大的,所以在区间范围比较小的时候,可以将排序改为插入排序,较为高效一些。

优化后的代码

int QuickSortPart(int*a, int left, int right)
{
	int* Maxi = (&a[left], &a[right], &(a[(left + right) / 2]));//三数取中
	Swap(&a[left], Maxi);//换到最左边
	int key = a[left];
	int keyi = left;
	while (left < right)
	{
		while (right > left)
		{
			if (a[right] < a[keyi])
				break;
			right--;
		}
		while (left < right)
		{
			if (a[left] > a[keyi])
				break;
			left++;
		}
		Swap(&a[right], &a[left]);
	}
	Swap(&a[left], &a[keyi]);
	return left;
}
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)//等于是只有一个数需要排,大于是没有数需要排
	{
		return;
	}
	int keyi = QuickSortPart(arr, begin, end);
	if (end - begin >= 5)
	{
		QuickSort(arr, begin, keyi - 1);
		QuickSort(arr, keyi + 1, end);
	}
	else
	{
		InsertSort(arr + begin, end - begin + 1);
		InsertSort(arr + keyi + 1, end - keyi);
	}
}

挖坑法

挖坑法思路和霍尔法基本相同,但思路更好理解一点。
选择一个‘坑位’(位置),这个坑位上就是要放 key 值的地方,先将坑位的这个值保存下来,右指针先向左走,找比key小的值,找到后将这个位置的值放入坑位,自己形成新的坑位,然后左指针向右走,找比key大的值,找到后将这个位置的值放入新生成的坑位,然后自己形成新的坑位…如此往复,直到 left 和 right 相遇形成的最后的坑位,将原来保留的key 值放入该坑位中,一趟就完成了。

挖坑法代码

int QuickSortPart(int*a, int left, int right)
{
	int* Maxi = (&a[left], &a[right], &(a[(left + right) / 2]));//三数取中
	Swap(&a[left], Maxi);//换到最左边
	int holei = left;
	int hole = a[left];
	while (left < right)
	{
		while (left < right && a[right] >= hole)
		{
			right--;
		}
		a[holei] = a[right];
		holei = right;
		while (left < right && a[left] <= hole)
		{
			left++;
		}
		a[holei] = a[left];
		holei = left;
	}
	return left;
}
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)//等于是只有一个数需要排,大于是没有数需要排
	{
		return;
	}
	int keyi = QuickSortPart(arr, begin, end);
	if (end - begin >= 5)
	{
		QuickSort(arr, begin, keyi - 1);
		QuickSort(arr, keyi + 1, end);
	}
	else
	{
		InsertSort(arr + begin, end - begin + 1);
		InsertSort(arr + keyi + 1, end - keyi);
	}
}

前后指针法

依旧是三数取中后取最左边的数的下标为keyi。定义一个指针prev指向left ,定义一个指针cur指向left+1,cur先往后遍历,如果找到比 key 小的数,则和prev先自加,再将prev位置和数和cur位置的数交换位置,如果找到大于等于key的数,cur 就继续往后遍历,而 prev 不动。
最后,将prev位置的值和 keyi 位置的值交换,再返回prev,相当于也是找到了那个key:调整后prev左边都是小于key的,右边都是大于key的。

int QuickSortPart4(int* a, int left, int right)
{
	int* Maxi = (&a[left], &a[right], &(a[(left + right) / 2]));
	Swap(&a[left], Maxi);
	int keyi =left;
	int cur = left+1;
	int prev = left;
	while (cur <= right)
	{
		if(a[cur] >= a[keyi])
		{
			cur++;
		}
		else
		{
			prev++;
			if(cur!=prev)//防止无用交换
			{
				Swap(&a[cur], &a[prev]);
			}
			cur++;
		}
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)//等于是只有一个数需要排,大于是没有数需要排
	{
		return;
	}
	int keyi = QuickSortPart4(arr, begin, end);
	if (end - begin >= 5)//小区间优化
	{
		QuickSort(arr, begin, keyi - 1);
		QuickSort(arr, keyi + 1, end);
	}
	else
	{
		InsertSort(arr + begin, end - begin + 1);
		InsertSort(arr + keyi + 1, end - keyi);
	}
}

精简版
建议学会上面的后再看这个

int QuickSortPart3(int* a, int left, int right)//快排快慢指针
{
	int* Maxi = (&a[left], &a[right], &(a[(left + right) / 2]));
	Swap(&a[left], Maxi);
	int keyi = left;
	int prev = left;
	int cur = left+1;
	while (cur <= right)
	{
		if (a[cur] < a[keyi]&& ++prev!= cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[prev],&a[keyi]);
	return prev;
}

快速排序非递归

快排的非递归版本要借助栈来实现,但也需要使用找 keyi 的函数。先将组需要排序的数据的最后一个元素和第一个元素依次入栈,保存后一次出栈,然后进行分割(分割的时候就已经调整过位置了)。分割后再将前面序列和后面序列的尾和首依次入栈,再保存前面的序列的首尾元素,依次出栈…直到栈空为止,栈空后,意味着数组所有数据已经调整结束。

void QuickSortNorn(int* a, int begin, int end)
{
	ST st;
	STInit(&st);
	STPush(&st,end);
	STPush(&st,begin);
	while (!STEmpty(&st))
	{
		int left =STTop(&st);
		STPop(&st);
		int right =STTop(&st);
		STPop(&st);
		int keyi = QuickSortPart1(a, left, right);
		if (keyi + 1 < right)
		{
			STPush(&st, right);
			STPush(&st, keyi + 1);
		}
		if (keyi - 1 > left)
		{
			STPush(&st, keyi - 1);
			STPush(&st, left);
		}
	}
	STDestroy(&st);
}

你可能感兴趣的:(数据结构与算法,算法,数据结构,c语言,排序算法)