数据结构与算法 | 快速排序：Hoare法，挖坑法，双指针法，非递归，优化

前两章讲解了排序中的选择排序和插入排序，这次就来讲一讲交换排序中的快速排序。

快速排序时间复杂度：平均 O(nlogn) 最坏 O(n2)

快速排序，顾名思义，它的排序的效率是非常高的，在数据十分杂乱的时候他的效率甚至能远远超过希尔排序和堆排序。而这个排序的核心思想就是以交换为核心的划分

还是以前的方法，首先讲解单趟的思路。

快速排序单趟的思路，就是先选定某个枢轴，以这个枢轴为基准，展开划分，划分的结果就是，这个枢轴的左边的数据全都比它小，而右边的数据全都比它大。而划分后枢轴的位置也就是它的最终位置，这样就完成了枢轴的归位

一般常用的划分方法有三种：Hoare法，挖坑法，双指针法，下面就来一一讲解

单趟排序—划分

Hoare法

Hoare法的思路非常简单，就是交换比枢轴大的值和比枢轴小的值
从两端开始，先从前面找到一个比枢轴大的数据，再从尾部找到一个比枢轴小的位置，然后将小的放在前面，大的后面，直到前后走到同一个位置，说明这个位置的前面都是比他小的，后面都是比它大的，所以再将枢轴和这个位置交换，就可以保证枢轴归位

int Hoare(int* arr, int begin, int end)
{int pivot = arr[end];//保存枢轴数据，用于对比int pivot_index = end;//保存枢轴下标while (begin < end){while (begin < end && arr[begin] <= pivot){++begin;}//从前往后找到比枢轴大的数据while (begin < end && arr[end] >= pivot){--end;}//从后往前找到比枢轴小的数据Swap(&arr[begin], &arr[end]);//交换两个数据的位置}Swap(&arr[begin], &arr[pivot_index]);//枢轴归位return begin;
}

例如
测试数据

 int arr[10] = { 46, 74, 53, 14, 26, 36, 86, 65, 27, 34 };

这就是一趟的思路，最后当两个指针走到一起时，该位置与枢轴交换，枢轴归位，左边比他大，右边比他小，单趟划分结束。

这就是Hoare划分的思路

挖坑法

挖坑法的思路的核心就是挖坑填数
首先在枢轴的位置挖一个坑，然后从前往后找到一个比枢轴大的数据，填进这个坑中，再将那个数据的位置也挖一个坑，然后从后往前找一个比枢轴小的值，填进刚刚的坑中，再将这个位置挖坑。然后循环，直到前后指针指向同一个位置，这时这就是最后一个坑，将最开始挖走的枢轴填进坑中，就完成了划分。
总结下来就是不停的将数据填进上一个数据的坑中，然后再将该数据的位置挖一个坑

int DigHole(int* arr, int begin, int end)
{int pivot = arr[end];//保留枢轴值，进行对比和填坑while (begin < end){while (begin < end && arr[begin] <= pivot){++begin;}arr[end] = arr[begin];//将比枢轴大的数据填入坑中while (begin < end && arr[end] >= pivot){--end;}arr[begin] = arr[end];//将比枢轴小的数据填入坑中}arr[begin] = pivot;//将枢轴填入坑中，归位return begin;
}

测试数据

 int arr[10] = { 46, 74, 53, 14, 26, 36, 86, 65, 27, 34 };

这就是一趟的排序过程，还是十分容易理解的

双指针法

这个方法比起前两个方法来说就显得有点难理解，但是代码也是这三种划分方法中最简洁的

前后指针法的核心思路就是将大的数据推到后面
前指针指向大的数据，后指针指向小的数据，不停交换将大的数据推向后面，小的数据放在前面。

当遇到cur比枢轴大的数据时， prev停下来，只让cur走，直到cur走到小于枢轴的数据时，prev前进，如果两者不同，则交换，因为此时prev指向的是原来cur指向的大的数据，而cur是小的数据，两者交换，即可将大的数据推向后面

//双指针法
int PrevCurMethod(int* arr, int begin, int end)
{int cur = begin, prev = begin - 1;int pivot = arr[end];while (cur < end){//当cur指向的数大于枢轴时，就只有cur前进//当cur指向的数据小于枢轴时，prev才前进，如果与cur位置不同则交换if (arr[cur] < pivot && ++prev != cur){Swap(&arr[cur], &arr[prev]);}++cur;}++prev;Swap(&arr[cur], &arr[prev]);return prev;
}

测试数据

 int arr[10] = { 46, 74, 53, 14, 26, 36, 86, 65, 27, 34 };

因为前几个数都比34小，所以直到cur走到14时才找到比枢轴小的值，这时prev前进一步走到46，两者不同，交换

这时26也比34小，prev前进，两者交换

cur再继续前进，走到27，prev再前进，两者交换

此时34走到枢轴位置，跳出循环， prev再走一步，这时再让枢轴和prev交换，这就是枢轴的最终位置

这就是枢轴的最终位置，划分结束

多趟排序

递归

理解了单趟，下面就该进行多趟的排序。因为上面说过，单趟的核心就是划分，每次将数据划分为两个区间，然后再将区间再度划分。
如图：

是不是看起来有点类似树的结构，每次通过划分将枢轴左右边划分为两个子序列，再对子序列划分，知道所有枢轴归位，数据有序，这就是多趟的思路。

在我们实现树形操作的时候通常都会使用递归来实现，因为这样更加代码更加精简且思路简单。

void QuickSort(int* arr, int begin, int end)
{//当begin和end处于同一位置时说明全部子序列都划分结束if (begin < end){int pivot = PrevCurMethod(arr, begin, end);//上面任意一种划分都可以QuickSort(arr, begin, pivot - 1);QuickSort(arr, pivot + 1, end);//分别划分枢轴左右端的区间//[begin][pivot - 1]和[pivot + 1][end]}
}

非递归

因为递归会不断在栈上创建新的栈帧，递归越深开辟的栈帧也越多，所以当数据过多时就会产生栈溢出的情况，这时如果我们利用非递归来实现，就不会有这样的问题，因为我们借助其他数据结构或者方法来进动态开辟，所以就会利用堆的空间，堆的空间比栈要大很多，所以很难有溢出的情况。

当然非递归也可以实现，但是会操作会相对来说更加复杂。

我们需要用到栈来模拟递归，我们通过将每次划分的左右区间入栈，然后通过区间来进行划分，而不是将数据入栈。

栈的实现之前有写过
https://blog.csdn.net/qq_35423154/article/details/104327861

首先放入其实的左右区间，然后将左右区间出栈，通过前面的几种方法划分后再将划分后的区间入栈，不断操作，直到栈为空，说明所有区间划分完成

void noRecursive(int* arr, int begin, int end)
{Stack s;StackInit(&s);StackPush(&s, begin);StackPush(&s, end);while (!StackEmpty(&s)){//因为入栈时先入左子树再入右子树，所以先出应该是右子树再出左子树int right = StackTop(&s);StackPop(&s);int left = StackTop(&s);StackPop(&s);int povit = PrevCurMethod(arr, left, right);//划分区间[left][povit - 1] [povit + 1][right]if (left < povit){StackPush(&s, left);StackPush(&s, povit - 1);}if (right > povit){StackPush(&s, povit + 1);StackPush(&s, right);}}StackDestroy(&s);
}

优化

优化枢轴：三数取中法

我们现在实现的快速排序会遇到一种情况，就是如果数据本身有序，这时快速排序的时间复杂度就会非常高，有时甚至比不上较为低级的交换排序冒泡排序，这时一种非常大的问题，原因就出在了我们默认选择固定的枢轴，所以解决的方法也很简单，优化枢轴的选择即可。

而我们用到的方法也很简单，通过比较begin , mid ,end三个数据，选择大小适中的数据作为枢轴即可。

//三数取中，优化枢轴, 保证中间值在end的位置
void chancePovit(int* arr, int begin, int end)
{int mid = ((end - begin) >> 1) + begin;//取中间数，之所以不直接相加除二是因为数据过大时可能整型溢出，同时除号效率也没有右移效率高。if (arr[begin] > arr[end]){Swap(&arr[begin], &arr[end]);}//当首位比末尾低时两者交换，较小的放在前面if (arr[mid] < arr[begin]){Swap(&arr[mid], &arr[begin]);}//将中间和首位交换，将较小的放在前面if (arr[end] > arr[mid]){Swap(&arr[end], &arr[mid]);}//将末尾和中间交换，将中间数据放在最后，也就是我们选择的枢轴位置end
}

只需要在选择枢轴前执行即可。

优化递归：尾递归优化

虽然讲了非递归实现，但是那种方法还是有点复杂，所以我们还有一种优化递归的方法，借助迭代来减少一轮的递归，减少对栈的消耗。

我们将if改为while，然后在递归划分左区间时，将begin改为右区间的首部，这样进入下一次循环的时候就会变为划分[pivot + 1][end]，也就是我们原本的右区间，这样我们就将原本的一部分递归改为了循环，大大的减少了对栈的消耗

void QuickSort_Plus(int* arr, int begin, int end)
{//这里将if改为whilewhile (begin < end){int pivot = PrevCurMethod(arr, begin, end);QuickSort(arr, begin, pivot - 1);begin = pivot + 1;//将begin的值改为右区间的首部， 这时到进入下一次循环的时候就等价于原来的递归右区间}
}

到这里，快速排序的几种划分和多趟思路就全部讲完了，其实快速排序并没有想象中的难，了解了具体思路后实现起来还是挺简单的。
下面给出所有代码

#include"Stack.h"//交换
void Swap(int* a, int* b)
{int temp = *a;*a = *b;*b = temp;
}//三数取中，优化枢轴, 保证中间值在end的位置
void chancePovit(int* arr, int begin, int end)
{int mid = ((end - begin) >> 1) + begin;if (arr[begin] > arr[end]){Swap(&arr[begin], &arr[end]);}if (arr[mid] < arr[begin]){Swap(&arr[mid], &arr[begin]);}if (arr[end] > arr[mid]){Swap(&arr[end], &arr[mid]);}
}// Hoare法
int Hoare(int* arr, int begin, int end)
{chancePovit(arr, begin, end);int pivot = arr[end];int pivot_index = end;while (begin < end){while (begin < end && arr[begin] <= pivot){++begin;}while (begin < end && arr[end] >= pivot){--end;}Swap(&arr[begin], &arr[end]);}Swap(&arr[begin], &arr[pivot_index]);return begin;
}//挖坑法
int DigHole(int* arr, int begin, int end)
{chancePovit(arr, begin, end);int pivot = arr[end];while (begin < end){while (begin < end && arr[begin] <= pivot){++begin;}arr[end] = arr[begin];while (begin < end && arr[end] >= pivot){--end;}arr[begin] = arr[end];}arr[begin] = pivot;return begin;
}//双指针法
int PrevCurMethod(int* arr, int begin, int end)
{int cur = begin, prev = begin - 1;chancePovit(arr, begin, end);int pivot = arr[end];while (cur < end){if (arr[cur] < pivot && ++prev != cur){Swap(&arr[cur], &arr[prev]);}++cur;}++prev;Swap(&arr[cur], &arr[prev]);return prev;
}//递归多趟
void QuickSort(int* arr, int begin, int end)
{if (begin < end){int pivot = PrevCurMethod(arr, begin, end);QuickSort(arr, begin, pivot - 1);QuickSort(arr, pivot + 1, end);}
}//优化递归
void QuickSort_Plus(int* arr, int begin, int end)
{while (begin < end){int pivot = PrevCurMethod(arr, begin, end);QuickSort(arr, begin, pivot - 1);begin = pivot + 1;}
}//非递归
void noRecursive(int* arr, int begin, int end)
{Stack s;StackInit(&s);StackPush(&s, begin);StackPush(&s, end);while (!StackEmpty(&s)){//因为入栈时先入左子树再入右子树，所以先出的应该是右子树再到左子树int right = StackTop(&s);StackPop(&s);int left = StackTop(&s);StackPop(&s);int povit = DigHole(arr, left, right);//划分区间[left][povit - 1] [povit + 1][right]if (left < povit){StackPush(&s, left);StackPush(&s, povit - 1);}if (right > povit){StackPush(&s, povit + 1);StackPush(&s, right);}}StackDestroy(&s);
}