文章目录
- 快速排序递归实现
- 霍尔法
- 优化
- 挖坑法
- 前后指针法
- 快速排序非递归
大家好，我是纪宁，这篇文章将向大家介绍非常有名气的一款排序：快速排序
回忆到我们刚开始学习C语言的时候。经常会使用到一个库函数：
qsort函数 ，O(N*logN) 的时间复杂度不知道比冒泡排序强了多少倍，那时候经常会想，我靠，这效率牛。那么这篇文章，就带大家深入理解快排的原理及它的多种实现方式。
时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定
快速排序递归实现
霍尔法
假如现在有一个数组，要对它进行升序排列，那么排好序后，每个数的位置都应该是固定的，快排的思路就是这样：先将一个数作为key（一般选择数组的最左边），然后定义两个指针分别从左右遍历数组（从右边开始），将比 key 大的数全部放在数组偏右边，将比 key 小的数全部放在数组偏左边，然后在两个指针相遇的地方，将这个位置的值与最左边的key 值进行交换，那么key 就放在了正确的位置，即 key 左边全部是小于 key 的，右边全部是大于 key 的数据。
结束后，以当前的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);
}
