目录
一：插入排序
1.1直接插入排序
1.2希尔排序
二：选择排序
2.1选择排序
2.2堆排序
三：交换排序
3.1冒泡排序
3.2快速排序
3.2.1Hoare版本
3.2.2双指针法
3.2.3非递归
一：插入排序
1.1直接插入排序
直接插入排序，可以有很多种写法，写法也比较简单，在这里，我主要介绍一种和希尔排序十分相似的思想，方便后续讲解希尔排序
在这里我们定义一个变量end，它用来记录下标，在这里我们认为[0,end]范围内的数组是有序的，然后将下标end+1所在的数组，与[0,end]范围内的数组比大小（所有排序讲解的均为升序），放在合适的位置 。
如果，a[end] > a[end+1]，我们即将a[end]的数字，放在end+1处，这是又会产生一个问题，我们是每次比较都要两个数字交换，还是让a[end]直接将a[end+1]覆盖呢？
直接覆盖肯定是首先就排除的，因为覆盖会使数据缺失，那就选每次比价，每次交换吗？
但是，如果数组长度很长，可能依次交换，并不能让a[end+1]放在合适的位置，这样看每次交换可能不如直接覆盖来的快，这时我们可以取一个折中的方法：在新建一个变量tmp，将a[end+1]的值存在tmp，让后直接覆盖就可以了，但是tmp不着急让在end处，我们将继续比较，找到正确的位置直接将tmp放入即可
由上图，可以写出代码：
//插入排序
//直接插入排序
void InsertSort(int* a, int n)
{for (int i = 0; i < n - 1; i++){//单趟,[0,end]为有序数组，将a[end+1]插入数组int end = i;int tmp = a[end + 1];while (end >= 0){if (a[end] > tmp){a[end + 1] = a[end];end--;}else{break;}}a[end + 1] = tmp;}}1.2希尔排序
希尔排序通过名字可以看出是一个名叫希尔的大佬创造的方法，而当时这位大佬在写这个代码的时候正是想通过自己的方法，改良直接插入排序，所以希尔排序的思想和上面的直接插入排序很相似。
希尔排序和直接插入排序相比所做出的优化就是，先进行预排序，让数组十分接近有序，在进行一次插入排序即可。
预排序，就是将间隔gap的数分为一组，在这一小组中先进行排序，排完这几个小组后，再将gap变小，继续进行进行预排序，随着gap的减少，每一小组的成员不断增加，知道gap减少到1，也就是直接插入排序，之后数组有序
控制一组颜色排序：
for (int i = 0; i < n - gap; i+= gap){int end = i;int tmp = a[end + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}排完一种颜色，再排下一组颜色，知道所有组排完，一趟排序结束
for(int j = 0; j< gap; j++)
{for (int i = j; i < n - gap; i++){int end = i;int tmp = a[end + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}
}此时此刻，我们排完一趟排序，已经用了三个循环，这样想，你是否觉得时间复杂度已经爆了呢？但是在数据十分庞大时，希尔排序也即是说比快排慢一点而已，所以大佬之所被称为大佬不是没有原因的。各位，请继续往下看，静等希尔排序的奇迹！
其实，前面排完一趟是，希尔当时的原版本，在这之后还有大佬，对这一段代码，进行了优化，时间复杂度并没有变化，只是代码更简洁一点用了两个循环。
思路，排每一组的第一个，然后第一个都排完以后，再同时排第二个
for (int i = 0; i < n - gap; i++){int end = i;int tmp = a[end + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}排完一趟以后，在最外面，再套上一层循环控制gap即可
//希尔排序
//预排序：接近有序
//直接排序：gap == 1，插入排序
void ShellSort(int* a, int n)
{int gap = n;while (gap > 1){ gap = gap / 3 + 1;//最后一次是1//先排每一组的第一个，排完以后依次类推for (int i = 0; i < n - gap; i++){int end = i;int tmp = a[end + gap];while (end >= 0){if (a[end] > tmp){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = tmp;}}}对于gap的取值，希尔的初始版本是gap /= 2,这样就可以保证gap最后一次是1
后来，又有人经过大量实验数据得出，gap模3时，效率最高，但是/3的最后结果可能是0，所以为了保证最后一次是0，gap = gap/3+1
二：选择排序
2.1选择排序
选择排序就十分简单粗暴，即使遍历一遍数组，选出最小的，然后让最小的与下标为0的数字互换，然后重复
再这里可以做一点小小的优化就是一次选出最大和最小
//选择排序
//选择排序
void SelectSort(int* a, int n)
{int begin = 0, end = n - 1;while (begin < end){int mini = begin, maxi = begin;for (int i = begin + 1; i <= end; i++){if (a[i] < a[mini])mini = i;if (a[i] > a[maxi])maxi = i;}Swap(&a[begin], &a[mini]);//如果maxi和bgein重合，前面begin和mini换了值以后，最大的数应该在mini下标if (begin == maxi)maxi = mini;Swap(&a[end], &a[maxi]);end--;begin++;}2.2堆排序
堆排序分为两个部分就是建堆和排序
建堆：由于升序建大堆
//向下调整
void AdjustDown(int* a, int parent, int n)
{int child = parent * 2 + 1;while (child < n){if (child + 1 < n && a[child + 1] > a[child]){++child;}if (a[child] > a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent *2+ 1;}else{break;}}
}//堆排序
void HeapSort(int* a, int n)
{//建堆:升序见大堆for (int i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(a, i , n);}//排序int end = n - 1;while (end > 0){Swap(&a[0], &a[end]);AdjustDown(a, 0, end);end--;}
}三：交换排序
3.1冒泡排序
冒泡排序就是将数组遍历一遍，建最大的数字冒到最后，然后最后一个位置不参与遍历，在从头开始遍历，找到次大的
代码如下：
//交换排序
//冒泡排序
void BubbleSort(int* a, int n)
{for (int j = 0; j < n - 1; j++){for (int i = 0; i < n - 1-j; i++){if (a[i] > a[i + 1]){Swap(&a[i], &a[i + 1]);}}}}3.2快速排序
3.2.1Hoare版本
对于单趟排序，根据上面位置，很多人会写出这样的单趟排序
int key = a[left];while (left < right){//右边先走，找小//还要保证在数组范围内while (left < right && a[right] > key){right--;}//左边找大while (left < right && a[left] < key){left++;}//此时left所在的位置大于key，right所在的位置小于keySwap(&a[left], &a[right]);}//此时left和right相遇Swap(&key, &a[left]);
此时，如果调试一下，会发现最后交换时，数组第一个值并没有变，因为创建了一个变量key，用来存最左边的值，相当于创建了一个临时变量，所以最后交换时，是临时变量，与数组中的值交换的，所以我们可以创建一个变量，用于存下标
解决了这个问题，循环条件，还有一个隐藏的条件，如果是以下数组，left和right如何呢？
单趟排序的代码：
int keyi = left;while (left < right){//右边先走，找小//还要保证在数组范围内while (left < right && a[right] > a[keyi]){right--;}//左边找大while (left < right && a[left] < a[keyi]){left++;}//此时left所在的位置大于key，right所在的位置小于keySwap(&a[left], &a[right]);}//此时left和right相遇Swap(&a[keyi], &a[left]);keyi = left;排完单趟以后，就是排整个数组，也就是递归，递推
完整的排序代码：
if (left >= right)return; //单趟int begin = left, end = right;int keyi = left;while (left < right){//右边先走，找小//还要保证在数组范围内while (left < right && a[right] > a[keyi]){right--;}//左边找大while (left < right && a[left] < a[keyi]){left++;}//此时left所在的位置大于key，right所在的位置小于keySwap(&a[left], &a[right]);}//此时left和right相遇Swap(&a[keyi], &a[left]);keyi = left;//[begin,keyi -1] keyi [keyi+1,end]//递归PartSort1(a, begin, keyi - 1);PartSort1(a, keyi + 1, end);以上是最基础的快排，但是在厉害的排序也是有自己的不足的，基础版的快排有一个不足就是，如果数组是顺序时，时间复杂度就会从n*logn变成n^2
这个问题会出现是因为我们每次都选择最左边的值作为key,为了解决这个问题，大佬们分别有不同的解决方法，比较常用的是随机值和三数取中
随机值法：顾名思义就是让key是个随机数，不再让key固定即使key，而为了让我们单趟写的代码不发生太大的变化，我们可以选出这个之后，再让这个值与left位置的值互换，这样代码处的left就可以继续使用了
//单趟int begin = left, end = right;//随机选取keyiint randi = rand() % (right - left);randi += left;Swap(&a[randi], &a[left]);int midi = GetMid(a, left, right);Swap(&a[midi], &a[left]);int keyi = left;while (left < right){//右边先走，找小//还要保证在数组范围内while (left < right && a[right] >= a[keyi]){right--;}//左边找大while (left < right && a[left] <= a[keyi]){left++;}//此时left所在的位置大于key，right所在的位置小于keySwap(&a[left], &a[right]);}//此时left和right相遇Swap(&a[keyi], &a[left]);keyi = left;//[begin,keyi -1] keyi [keyi+1,end]//递归PartSort1(a, begin, keyi - 1);PartSort1(a, keyi + 1, end);三数取中：三数取中并不是取下标的中间值，而是取下标处的数组值的中间值，三数取中应用有序数组可以将复杂度再拉回n*logn
//三数取中
int GetMid(int* a, int left, int right)
{int midi = (left + right) / 2;if (a[left] > a[midi]){if (a[midi] > a[right])return midi;//a[midi] 最小else if (a[left] < a[right])return left;elsereturn right;}else//a[left] < a[midi]{if (a[midi] < a[right])return midi;//a[midi]最大else if (a[left] > a[right])return left;elsereturn right;}
}而有的大佬，为了让快排更快，有做出了一些优化
递归过程，越往下所占总体比例越大 ，和二叉树类似，最后一层就占总体的50%，而且越往下数组区间越小，因此下面区间小的数组就不值得再往下递归了，之间排序了，一般当数组区间小于10时，就用插入排序
// 快速排序hoare版本//三数取中
int GetMid(int* a, int left, int right)
{int midi = (left + right) / 2;if (a[left] > a[midi]){if (a[midi] > a[right])return midi;//a[midi] 最小else if (a[left] < a[right])return left;elsereturn right;}else//a[left] < a[midi]{if (a[midi] < a[right])return midi;//a[midi]最大else if (a[left] > a[right])return left;elsereturn right;}
}
void PartSort1(int* a, int left, int right)
{if (left >= right)return;if (right - left + 1 < 10){InsertSort(a, right - left + 1);}else{//单趟int begin = left, end = right;//随机选取keyi//int randi = rand() % (right - left);//randi += left;//Swap(&a[randi], &a[left]);int midi = GetMid(a, left, right);Swap(&a[midi], &a[left]);int keyi = left;while (left < right){//右边先走，找小//还要保证在数组范围内while (left < right && a[right] >= a[keyi]){right--;}//左边找大while (left < right && a[left] <= a[keyi]){left++;}//此时left所在的位置大于key，right所在的位置小于keySwap(&a[left], &a[right]);}//此时left和right相遇Swap(&a[keyi], &a[left]);keyi = left;//[begin,keyi -1] keyi [keyi+1,end]//递归PartSort1(a, begin, keyi - 1);PartSort1(a, keyi + 1, end);}
}3.2.2双指针法
除了Hoare原本的版本以外，还有用双指针法来写快排
代码：
/ 快速排序前后指针法
void PartSort3(int* a, int left, int right)
{if (left >= right)return;int begin = left, end = right;int midi = GetMid(a, left, right);Swap(&a[midi], &a[left]);//单趟int keyi = left;int prev = left;int cur = left + 1;while (cur <= end){if (a[cur] < a[keyi] && ++prev != cur)Swap(&a[cur], &a[prev]);cur++;}Swap(&a[keyi], &a[prev]);keyi = prev;//[begin, keyi-1] keyi [end, keyi+1]PartSort3(a, begin, keyi - 1);PartSort3(a, keyi+1, end);
}3.2.3非递归
快排不一定必须要用递归，也可以借助栈来实现
