🌈个人主页:羽晨同学
💫个人格言:“成为自己未来的主人~”
快速排序
递归hoare版本
首先,我们先来看一段示意图:
我们根据这份原理图就可以很清楚的看到快速排序的底层原理。
我们将key定义在初始位置。然后让右边先走,找到比key小的数字,然后左边再走,找到比key大的数字,然后两个发生交换,最后两者相遇,相遇位置就是key的位置的数字应该存在的位置。
首先,我们对快速排序进行声明:
//Sort.h
// 快速排序递归实现
// 快速排序hoare版本
void PartSort1(int* a, int left, int right);
接下来,我们对快速排序进行定义:
//Sort.c
// 快速排序递归实现
// 快速排序hoare版本
void PartSort1(int* a, int left, int right)
{
int keyi = left;
int begin = left;
int end = right;
if (left > right)
return;
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[keyi], &a[left]);
keyi = left;
PartSort1(a, begin, keyi - 1);
PartSort1(a, keyi+1,end);
}
测试部分:
//Test.c
#define _CRT_SECURE_NO_WARNINGS
#include"Sort.h"
int main()
{
int a[] = { 4,5,8,9,2,1,0,5,8,5 };
PartSort1(a, 0,sizeof(a)/sizeof(int)-1);
for (int i = 0; i < sizeof(a) / sizeof(int); i++)
{
printf("%d ", a[i]);
}
return 0;
}
挖坑法
我们其实可以很明显的观察到,这个和前面的hoare是极其相似的。
那下面,我们就来实现一下挖坑法:
//Sort.c
// 快速排序挖坑法
void PartSort2(int* a, int left, int right)
{
int keyi = a[left];
int begin = left;
int end = right;
if (left > right)
return;
while (left < right)
{
while (left<right && a[right]>=keyi)
right--;
Swap(&a[left], &a[right]);
while (left < right && a[left] <= keyi)
left++;
Swap(&a[right], &a[left]);
}
a[left] = keyi;
PartSort2(a, begin, left - 1);
PartSort2(a, left + 1, end);
}
前后指针法
接下来,我们介绍一下快速排序的双指针的实现方法:
我们首先仍是一样的,将初始位置的值定义为key,定义prev和cur,然后在cur指向的值不超过key的前提下,cur走一步,prev走一步,在什么时候二者分开呢?那就是当cur指向的值超过key的时候,然后当cur的值小于key的时候,二者发生交换,并在最后当cur越界的时候,prev和key进行交换。
下面,我们具体说一下,前后指针法的实现逻辑。
// 快速排序前后指针法
void PartSort3(int* a, int left, int right)
{
int keyi = left;
int begin = left;
int end = right;
int prev = left;
int cur = left + 1;
if (left >= right)
return;
while (cur<=end)
{
if ( a[cur] < a[keyi] && ++prev != cur)
Swap(&a[prev], &a[cur]);
cur++;
}
Swap(&a[prev], &a[keyi]);
keyi = prev;
PartSort3(a, begin, keyi - 1);
PartSort3(a, keyi + 1, end);
}
其实前后指针法相对于前面的两种方法来说,真的可以算的上是代码简单。
快速排序无递归版本
大家可能不了解为什么会需要这种不需要递归的版本,这是因为,对于递归是需要开辟栈帧的,对于,快速排序而言,一旦递归次数过多,就会导致栈的溢出。
这种情况就是无递归版本的应用场景。
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
ST st;
STInit(&st);
STPush(&st, right);
STPush(&st, left);
while (!STEmpty(&st))
{
int begin = STTop(&st);
STPop(&st);
int end = STTop(&st);
STPop(&st);
// 单趟
int keyi = begin;
int prev = begin;
int cur = begin + 1;
while (cur <= end)
{
if (a[cur] < a[keyi] && ++prev != cur)
Swap(&a[prev], &a[cur]);
++cur;
}
Swap(&a[keyi], &a[prev]);
keyi = prev;
if (keyi + 1 < end)
{
STPush(&st, end);
STPush(&st, keyi + 1);
}
if (begin < keyi - 1)
{
STPush(&st, keyi - 1);
STPush(&st, begin);
}
}
STDestroy(&st);
}
我们主要是利用的栈的性质模仿递归的过程,其最重要的部分就是left和right,我们就可以利用栈来得到新的left和right
改进
为了提高快速排序的效率,几位大佬创造了三数取中法,和随机值法,来改变keyi的值,来提高快速排序的效率。
小区间优化
我们可以肯定的是,当一个数组中的数值个数较少时,使用快速排序开辟新的栈帧是极其浪费的,这个时候最好的方式就是使用插入排序。
if (right - left + 1 < 10)
{
InsertSort(a + left, right - left + 1);
}
随机数法
int randi = rand() % (right - left + 1);
randi += left;
Swap(&a[left], &a[randi]);
三数取中
int GetMidi(int* a, int left, int right)
{
int mid = (left + right) / 2;
//printf("%d %d %d", left, mid, right);
//printf("->%d %d %d\n", a[left], a[mid], a[right]);
if (a[left] < a[mid])
{
if (a[mid] < a[right])
{
return mid;
}
else if (a[left] > a[right])
{
return left;
}
else
{
return right;
}
}
else // a[left] > a[mid]
{
if (a[mid] > a[right])
{
return mid;
}
else if (a[left] < a[right])
{
return left;
}
else
{
return right;
}
}
}
int midi = GetMidi(a, left, right);
//printf("%d\n", midi);
Swap(&a[left], &a[midi]);