交换排序（快排）
当当当当！终于来到了令人激动人心的环节：交换排序！在这里，我们将会学习到一个大家经常听到过的名词：快速排序，而我希望通过这篇文章的学习，大家也能够真正的学会快排！
交换排序
基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
冒泡排序
冒泡排序的特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
其实博主之前的文章中也有写过冒泡排序，如果大家有不了解的，可以直接跳转到此篇文章进行观看：https://blog.csdn.net/Rainai/article/details/132239596
博主在这里就不详细介绍冒泡排序啦~
快速排序
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int array[], int left, int right)
{
if(right - left <= 1)
return;
// 按照基准值对array数组的 [left, right)区间中的元素进行划分
int div = partion(array, left, right);
// 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
// 递归排[left, div)
QuickSort(array, left, div);
// 递归排[div+1, right)
QuickSort(array, div+1, right);
}
上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后续只需分析如何按照基准值来对区间中数据进行划分的方式即可。
将区间按照基准值划分为左右两半部分的常见方式有：
- hoare版本
hoare版本的快排会有很多很多坑，我先一一为大家把坑都列出来，看看大家是否理解
//单趟
void QuickSort(int* a,int n){
int left=0,right=n-1;
int key=a[left];
while(left<right){
//右边找小
while(a[right]>key){
--right;
}
//左边找大
while(a[left]<key){
--left;
}
Swap(&a[left],&a[right]);
}
Swap(&a[left],&key);
}
这里的问题在于①相遇位置的判断：做不到相遇会停的条件,需要将left
那么我们更改后是这个样子的：
//单趟
void QuickSort(int* a,int n){
int left=1,right=n-1;
int key=0;
while(left<right){
//右边找小
while(left<right && a[right]>a[key]){
--right;
}
//左边找大
while(left<right && a[left]<a[key]){
--left;
}
Swap(&a[left],&a[right]);
}
Swap(&a[left],&a[key]);
}
当我们把单趟排好之后，我们的左边是小的，右边是大的，如果左边和右边也有序，那么就可以达成总体有序
这个时候，我们可以把其分为左子树，根，右子树的形式来看，就拿动图的例子来讲：此时6就相当于根节点，而左右两边就是左子树和右子树，接下来再对左右两边也按照这样的方法来操作即可
就拿左边的3 1 2 5 4举例，3是a[key]，如果进行交换，右边找小到2，左边也找大，找不到，到2相遇，然后2和3交换，刚好成为2 1 3 5 4，这个时候需要排的就是2 1和5 4了,向左找根；然后就是2和1换，5和4换，最后只有1或者4的时候，我们就不需要再换啦，而这个范围，我们可以大致理解为这样子：[begin,key-1] key [key+1,end]
所以，我们发现，如果要走全趟，就需要①递归②更改函数结构
void QuickSort(int* a,int begin,int end){
if(begin>=end)
return;//递归判断条件
int left=begin+1,right=end-1;
int key=begin;
while(left<right){
//右边找小
while(left<right && a[right]>a[key]){
--right;
}
//左边找大
while(left<right && a[left]<a[key]){
--left;
}
Swap(&a[left],&a[right]);
}
Swap(&a[left],&a[key]);
key=left;//换了位置，下标也要换咧
QuickSort(a,begin,key-1);
QuickSort(a,key+1,end);
}
//[begin,key-1] key [key+1,end]这个区间可能不存在
//拿之前的2 1 3 5 4举例，5和4的下标是3和4
//begin是3，key-1是3，key是4，key+1是5，end是4
//这种区间左边就是一个值的区间，右边就是不存在的区间
大家是不是以为这样子快排就写好了，可是事实上我们还有一些坑仍未填好，大家别着急，我们继续往下看
这个时候假如我们把数组改为这个样子：6 1 2 6 7 9 3 4 6 10 8，启动程序会发现进入了死循环，这又是为什么呢？
左边找大，右边找小，左边从1开始，右边从8开始，8找，找到6停下了；左边也是找到6停下了，然后就是6和6换，没有意义，所以我们完全可以把while的判断条件加上一个=
修改之后，我们还会发现另一个问题，1 2 3 4 6 6 7 6 8 9 10是输出的结果，为什么7会在6的前面呢?我们经过调试，会发现左边实际上是没有问题的，但在右边递归的时候，一开始是9 7 6 10 8，变成8 7 6 9 10，left和right会在下标为8的位置上相遇，在排序8 7 6的时候出现了问题，进行第一次swap的时候，成为了6 7 8 9 10，是没有问题的，但是在递归左边时，6和7直接就进行了互换，因为右边要找小，而有序的情况下就会导致直接互换
所以我们再次进行修改：
void QuickSort(int* a,int begin,int end){
if(begin>=end)
return;//递归判断条件
int left=begin,right=end;
int key=begin;
while(left<right){
//右边找小
while(left<right && a[right]>=a[key]){
--right;
}
//左边找大
while(left<right && a[left]<=a[key]){
--left;
}
Swap(&a[left],&a[right]);
}
Swap(&a[left],&a[key]);
key=left;
QuickSort(a,begin,key-1);
QuickSort(a,key+1,end);
}
如果想随时更换使用方法，那么就可以这么写，当然，我们得先把hoare版本的方法作为函数提取出来
//hoare版本
int PartSort1(int* a, int begin, int end)
{
int midi = GetMidi(a, begin, end);
Swap(&a[midi], &a[begin]);
int left = begin, right = end;
int keyi = begin;
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[left], &a[keyi]);
return left;
}
而下面这个就是快排大概的一个模板写法：
void QuickSort(int* a, int begin, int end) {
if (begin >= end)
return;
int key = partSort(a, begin, end);
QuickSort(a, begin, key - 1);
QuickSort(a, key + 1, end);
}
只要更改partSort的方法，而这个模板并不需要改变就可以测试效果，使用起来肯定比每次都要写一大堆快捷方便
虽然此刻快速排序的功能已经发展齐全，但是其中还有一些需要控制的问题。比如当我们测试代码的运行效率时，虽然正常的时候，其量级都是NlogN，尤其是当排序的数据出现二分的情况，但是如果代码本身有序，那么其效率就会低的离谱，成为N^2，如果要排序的数据量过大，甚至还会出现栈溢出，这个时候就需要我们手动写出一个函数，在每次排序的时候将一个不大也不小的值当作key，就不会出现效率低下的问题了
int GetMid(int* a, int begin, int end) {
// 在begin和end之间选择一个中位数
int mid = (begin + end) / 2;
if (a[begin] <= a[mid] && a[mid] <= a[end]) {
return mid;
}
else if (a[begin] > a[mid]) {
// 如果a[begin]大于a[mid]，那么中位数要么在a[begin]的位置，要么在a[end]的位置
return (a[begin] <= a[end]) ? begin : end;
}
else {
// 如果a[begin]小于a[mid]，那么中位数要么在a[mid]的位置，要么在a[end]的位置
return (a[mid] <= a[end]) ? mid : end;
}
}
而在这个部分的最后，我们还要讲的一个点是：为什么left和right的相遇位置总是比key要小？结论是右边先走，我们给大家分析一下：
大家自己画画图也会发现，情况就是这样的
以上我们讲解的方法其实就是第一种快排的方法，是hoare写出来的，所以也叫做hoare法，这个方法大家会发现有很多坑，所以实际情况下我们并不建议去写这种方法，而以下的两个方法，相信大家看了之后相比较于这个会觉得非常简单
- 挖坑法
首先，选择数列中的一个位置作为起始点，并标记为“坑位”。然后，从数列的两端开始，分别向这个坑位移动。（比如这里就是右边先移）在移动过程中，如果左边的数字比坑位上的数字大，或者右边的数字比坑位上的数字小，就继续移动。一旦左边的数字小于等于坑位上的数字，或者右边的数字大于等于坑位上的数字，就将当前位置与坑位交换。重复这个过程，直到左边的指针和右边的指针相遇。最后，将起始位置的值填入相遇点。（坑位上的数字就是一开始取出来的key）
代码如下：
int partSort2(int* a, int begin, int end) {
int mid = GetMid(a, begin, end);
Swap(&a[mid], &a[begin]);
int key = a[begin];//key值
int hole = begin;//起始坑位
while (begin < end) {
//右边找小，填到左边的坑
while (begin < end && a[end] >= key) {
--end;
}
a[hole] = a[end];//找到小的了，把end位置的值填进原来的坑里
hole = end;//现在的end位置变成坑
//左边找大，填到右边的坑
while (begin < end && a[begin] <= key) {
++begin;
}
a[hole] = a[begin];//找到大的了，把begin位置的值填进坑里
hole = begin;//现在的begin位置变成坑
}
a[hole] = key;//最后把一开始取出的坑位值塞进洞里（begin和end相交后）
return hole;//返回坑位下标
}
- 前后指针法
上述的两个方法实际上的想法都是差不多的，但下面的指针法，跟上面的两种方法思想就不太一样了
通过上面的图，我们也可以概括以下两点：
1.cur遇到比key大的值，++cur
2.cur遇到比key小的值，++prev，交换prev和cur位置的值，++cur
int partSort3(int* a, int begin, int end) {
int mid = GetMid(a, begin, end);
Swap(&a[mid], &a[begin]);
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;//因为两种情况下都涉及到++cur
}
Swap(&a[prev], &a[keyi]);
keyi = prev;
return keyi;//这样写逻辑更清晰，其实可以直接return prev
}
另外，除了以上几种方法，我们还需要了解一个优化的小tips，虽然在release版本下面并无法起到太大的作用
我们知道满二叉树最后一层占领的节点是将近所有节点一半的节点，引申到快排，我们会发现，在排序的过程中，也是最后几次排序消耗更多，我们不断分割并且对左边展开递归，比如，为了让7个数有序，我们会这样做：
那么7个数就递归了7次，这样子的话，消耗的栈空间会很多，为了减少栈空间的消耗，我们选择小区间优化，选择最后三层到四层进行插入排序；不过需要记住的是，虽然是优化，但有时候效果并不会特别好，因为这两种方法的效率差距就是减少的递归和增加的插入排序的性能的差距，所以用与不用全看个人
void quickSort(int* a, int begin, int end) {
if (begin >= end) {
return;
}
//小区间优化 选择最后三到四层
if (end - begin + 1 <= 10) {
InsertSort(a+begin, end - begin + 1);//这里不是从a开始的，而是从a+begin开始的
}
else {
int mid = GetMid(a, begin, end);
Swap(&a[begin], &a[mid]);
int left = begin, right = end;
int key = begin;
while (left < right) {
//右边找小
while (left < right && a[right] >= a[key]) {
--right;
}
//左边找大
while (left < right && a[left] <= a[key]) {
++left;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[key]);
key = left;
quickSort(a, begin, key - 1);
quickSort(a, key + 1, end);
}
}
下面我们将要进行另外一个重要方法的讲解，非递归快排！
非递归快排（栈）
在以前，我们用非递归实现递归的时候，就需要使用到循环，比如斐波那契数列等等，但可以用循环实现的，大概率也没有必要使用递归，所以这里我们要介绍一种新方法：利用栈来仿造递归的效果
栈利用的是堆空间，比起递归使用的栈空间来说很大，完全可以使用
就比如我们还是拿刚才的数组来举例，我们先让0和9进栈，然后它出栈之后key=5，分割为[0,4]和[6,9]，[0,4]后进的原因是因为我们这里规定的是先递归左边的，由于栈又是后进先出，所以这样安排；0，4出出来之后，其key为2，所以范围变为[0,1]和[3,4]，先出0，1之后发现其后面的范围变为[0,0]（单元素区间）和[2,1]（不存在区间），则出栈后后面不再入栈，3和4同理。
有些同学会想需不需要把栈的元素类型改成数组，这样子一组才能塞两个元素进去，其实也没有必要，看完代码你就明白了！
//非递归快排
void QuickSortNonR(int* a, int begin, int end)
{
ST s;
STInit(&s);//创建栈
STPush(&s, end);
STPush(&s, begin);//首尾进去
while(!STEmpty(&s))//栈不为空
{
int left = STTop(&s);
STPop(&s);//记得出出去，不然拿不到下面的
int right = STTop(&s);
STPop(&s);
int keyi = PartSort(a, left, right);//这个写哪个都可以
// [left, keyi-1] keyi [keyi+1, right] 取值范围
if (left < keyi - 1)//等于或者大于，这个区间都是没有意义的
{
STPush(&s, keyi - 1);
STPush(&s, left);
}
if (keyi + 1 < right)//同理
{
STPush(&s, right);
STPush(&s, keyi+1);
}
}
STDestroy(&s);
}
运行之后，其实结果也是一样的，以上几种方式在效率方面均没有太大差距，只是实现的思路不大相同。而且，虽然有些地方思想上看的明白，但是轮到自己写时也还是会不太清晰，所以希望大家也可以自己多看多写，以达到真正的理解！