上节中我们学习了七大排序中的五种(插入排序、希尔排序、堆排序、选择排序、交换排序)
数据结构-常见的七大排序-CSDN博客
这节我们将要学习快速排序(hoare、指针法、挖洞法(快排的延伸)、快速排序非递归(栈))
1.快速排序
1.1 hoare法
1.1思路
1.选出一个key，一般是最左边或是最右边的。
2.定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）。
3.在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）
4.此时key的左边都是小于key的数，key的右边都是大于key的数
5.将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作，此时此部分已有序
1.2单趟动图如下：
1.3画图思路如下（单边）
代码如下：
//快速排序 hoare版本(左右指针法)
void QuickSort(int* arr, int begin, int end)
{
//只有一个数或区间不存在
if (begin >= end)
return;
int left = begin;
int right = end;
//选左边为key
int keyi = begin;
while (begin < end)
{
//右边选小 等号防止和key值相等 防止顺序begin和end越界
while (arr[end] >= arr[keyi] && begin < end)
{
--end;
}
//左边选大
while (arr[begin] <= arr[keyi] && begin < end)
{
++begin;
}
//小的换到右边，大的换到左边
swap(&arr[begin], &arr[end]);
}
swap(&arr[keyi], &arr[end]);
keyi = end;
//[left,keyi-1]keyi[keyi+1,right]
//无限向下分，直到一个数或为NULL
QuickSort(arr, left, keyi - 1);
QuickSort(arr,keyi + 1,right);
}
时间复杂度:
快速排序的过程类似于二叉树其高度为logN，每层约有N个数，如下图所示：
2.1前后指针法
2.1思路
1.选出一个key，一般是最左边或是最右边的。
2.起始时，prev指针指向序列开头，cur指针指向prev+1。
3.若cur指向的内容小于key，则prev先向后移动一位，然后交换prev和cur指针指向的内容，然后cur指针++；若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur到达end位置，此时将key和++prev指针指向的内容交换即可。经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。
然后也还是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作
2.2单趟动图如下：
代码如下：
//快速排序法 前后指针版本
void QuickSort2(int* arr, int begin, int end)
{
if (begin >= end)
return;
int cur = begin, prev = begin - 1;
//前后指针
int keyi = end;
while (cur != keyi)
{
if (arr[cur] < arr[keyi] && ++prev != cur)
{
swap(&arr[cur], &arr[prev]);
}
++cur;
}
swap(&arr[++prev],&arr[keyi]);
keyi = prev;
//[begin,keyi -1]keyi[keyi+1,end]
//与hoare类似，但又有不同
QuickSort2(arr, begin, keyi - 1);
QuickSort2(arr, keyi + 1, end);
}3.1挖洞法
3.1思路
挖坑法思路与hoare版本(左右指针法)思路类似
1.选出一个数据（一般是最左边或是最右边的）存放在key变量中，在该数据位置形成一个坑
2、还是定义一个L和一个R，L从左向右走，R从右向左走。（若在最左边挖坑，则需要R先走；若在最右边挖坑，则需要L先走）
3.2单趟动图如下：
代码如下：
//快速排序法 挖坑法
void QuickSort1(int* arr, int begin, int end)
{
if (begin >= end)
return;
int left = begin,right = end;
int key = arr[begin];
//这里的key就为洞
while (begin < end)
{
//找小
while (arr[end] >= key && begin < end)
{
--end;
}
//小的放到左边的坑里
arr[begin] = arr[end];
//找大
while (arr[begin] <= key && begin < end)
{
++begin;
}
//大的放到右边的坑里
arr[end] = arr[begin];
}
arr[begin] = key;
int keyi = begin;
//[left,keyi-1]keyi[keyi+1,right]
QuickSort1(arr, left, keyi - 1);
QuickSort1(arr, keyi + 1, right);
}4.1快速排序非递归(栈)
与hoare快排类似，这里是利用栈的特点(先进后出，后进先出)
代码如下：
int PartSort2(int* a, int left, int right)
{
// 三数取中，为了提高排序效率
//这里可以省略
int midi = GetMidi(a, left, right);
Swap(&a[left], &a[midi]);
int keyi = left;
int prev = left;
int cur = prev + 1;
while (cur <= right)
{
if (a[cur] < a[keyi] && ++prev != cur)
Swap(&a[prev], &a[cur]);
cur++;
}
Swap(&a[prev], &a[keyi]);
return prev;
}void QuickSortNonHeap(int* a, int left, int right) {
Stack st;
StackInit(&st);
StackPush(&st, right);
StackPush(&st, left);
while (!StackEmpty(&st) ){
int begin = StackTop(&st);
STpop(&st);
int end = StackTop(&st);
STpop(&st);
int keyi = PartSort2(a, begin, end);
if (keyi + 1 < end)
{
StackPush(&st, end);
StackPush(&st, keyi + 1);
}
if (begin < keyi - 1)
{
StackPush(&st, keyi - 1);
StackPush(&st, begin);
}
}
StackDestroy(&st);
}2.计数排序
2.1思路
计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：1. 统计相同元素出现次数2. 根据统计的结果将序列回收到原来的序列中
代码如下：
void CountSort(int* a, int n) {
int min = a[0], max = a[0];
//找最小最大
for (int i = 0; i < n; i++) {
if (a[i] > max) {
max = a[i];
}
if (a[i] < min) {
min = a[i];
}
}
int range = max - min + 1;
//calloc开辟空间，存放值为0
//malloc开辟空间，存放值为任意值;
int* count = (int*)calloc(range, sizeof(int));
if (count == NULL)
{
perror("calloc fail");
return;
}
//统计次数
for (int i = 0; i < n; i++) {
count[a[i] - min]++;
}
//排序
int j = 0;
for (int i = 0; i < range; i++) {
while (count[i]--) {
a[j++] = i + min;
}
}
free(count);
}1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。2. 时间复杂度：O(MAX(N,范围))3. 空间复杂度：O(范围)4. 稳定性：稳定
排序算法复杂度与稳定性
我们学习排序算法的目的是为了更快的效率，如下列举了基本算法的时间复杂度、空间复杂度，及稳定性
对于少量数据，可用冒泡排序、直接插入排序、简单排序排序，相对简单
对于大量数据，可用堆排序、快速排序归并排序，但要注意他们的使用条件
![[陇剑杯 2021]wifi WP](https://i-blog.csdnimg.cn/direct/f0a94071ecf64ec1b22d84c0b926484d.png)
