注：本篇博客排序算法的实现默认都以升序为例
目录
第一层境界：一组有序数据 插入 数tmp 使其有序（预备工作）
第二层境界：一组数据从乱序到升序(真正的插入排序)(第一层境界的变形~)
思想：数组一分为二，整体有序则需左右有序，左右有序则递归即可~
一、(直接)插入排序
第一层境界：一组有序数据 插入 数tmp 使其有序（预备工作）
思想：倒着依次比较数组元素和tmp大小，a[end]>tmp,数组元素后移，end-- ; a[end]<tmp,直接插入到 end+1 位置
关键：情况一和情况二最后均要执行 a[end+1]=tmp 该语句
代码实现：
void InsertSort(int* a, int n)
{
int tmp;//一堆已经有序的数中插入tmp
int end;//end为数组中最后一个数的下标
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + 1] = a[end];
--end;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
第二层境界：一组数据从乱序到升序(真正的插入排序)(第一层境界的变形~)
思想：把境界一套进for循环
过程阐释：这是数组数据逐个插入排序的过程，第一个数显然不需要参与排序，tmp是每次要插入的值
两种写法的不同仅在于下标的控制而已，本质一样
//写法一：
void InsertSort(int* a, int n)
{
for (int i = 1;i < n;i++)
{
int tmp = a[i];
int end = i - 1;
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + 1] = a[end];
--end;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}//写法二：
void InsertSort(int* a, int n)
{
for (int i = 0;i < n-1;i++)
{
int tmp = a[i+1];//保存待比较数据,防止数据被覆盖丢失
int end = i;
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + 1] = a[end];
--end;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}
插入排序算法性能分析：
时间复杂度：
最坏 : 逆序最坏---O(N^2)
最好：顺序最好---O(N)(√) O(1)(×) 因为至少每个数都要和前一个数据比较一次
二、希尔排序
两大步骤：
1.预排序---使数组元素接近有序
实现预排序方法：分组，将数据每隔gap分一组，一共可以分gap组，利用直接插入排序的思想，实现每组数据有序，整体就接近有序
2.直接插入排序
每组排好序后，再用直接插入排序就可以更快地实现排序
第一层境界：gap组数据之每组数据的排序
每组数据的排序本质就是直接插入排序，但是每一组元素不是紧邻了，改一改代码即可~
以第1组数据的排序为例：
1.类比直接插入排序即可，注意相邻元素之间下标间隔gap即可，i+=gap
2.注意i范围，由于进入循环后要执行tmp = a[i+gap] 这句代码，因此 i <n-gap
void ShellSort(int* a, int n)
{
int gap = 3;
for (int i = 0;i < n - gap;i += gap)
{
int end = i;
int tmp = a[i + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}第二层境界：循环实现gap组数据的各组排序
写法一：三层循环(两层for，一层while）
第一层境界代码示例只解决了第1组数据排序，那其他组呢？毫无疑问，外层套上for循环
一共有gap组，外层循环j的范围就从0到gap即可，内层循环i每次从j开始即可，这样就实现了第1组数据有序--->第二组数据有序--->····················第gap组数据有序
void ShellSort(int* a, int n)
{
int gap = 3;
for (int j = 0;j < gap;j++)
{
for (int i = j;i < n - gap;i += gap)
{
int end = i;
int tmp = a[i + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}写法二：两层循环，更加简洁
写法一是每组数据彻底排好序后才进行下一组排序，而写法二是多组并排，不同组同时进行排序
void ShellSort(int* a, int n)
{
int gap = 3;
for (int i = 0;i < n - gap;i++)
{
int end = i;
int tmp = a[i + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
第三层境界：gap组数据的最终排序算法
前两层境界都是在实现希尔排序的第一个步骤---预排序，第三层境界就要实现最后的总体排序了，方法就是直接插入法，难道还需要再写一段直接插入排序代码吗？ no!
直接插入排序的本质其实就是gap取1，所以我们只需要让gap最终取到1，就实现了目的~
关键代码就是 gap = gap/3+1, 因为gap最终越除越小，最后gap/3必然可以取到0，再加1就是gap=1的情况，就自动实现了最终的直接插入排序
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
//也可以写成gap = gap / 2;
for (int i = 0;i < n - gap;i++)
{
int end = i;
int tmp = a[i + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}希尔排序的特性总结：
1.希尔排序是对直接插入排序的优化
2.gap取值对排序的影响：
总结：gap>1都是预排序，gap==1时，数组已经接近有序，整体而言达到了优化的效果
细节：①gap越大，大的数可以更快到后面，小的数可以更快到前面，但越不接近有序
②gap越小，大数据和小数据都挪动越慢，但是越接近有序
③gap == 1， 就是直接插入排序
3.希尔排序的时间复杂度：
这是一个尚未证明的问题，有人总结出了经验公式，我们且认为是在O(n^1.25) 到 O(1.6*n^1.25)
三、冒泡排序
第一层境界：傻傻比较走全程
内层循环控制比较次数，外层循环控制趟数，冒泡本质是相邻数比较，两两交换，大数下沉~
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void BubbleSort(int* a, int n)
{
for (int i = 0;i < n - 1;i++)
{
for (int j = 0;j < n - 1 - i;j++)
{
if (a[j] > a[j + 1])
{
Swap(&a[j], a[j + 1]);
}
}
}
}
第二层境界：边走边看中途停(第一层境界的优化)
第一层境界要比较n-1趟，无论中间排序排的如何了，甚至有序了，还是会走完余下趟数~
而第二层境界 是当某一趟走完发现没有发生任何元素的交换，那就说明已经有序了，直接跳出
void BubbleSort(int* a, int n)
{
for (int i = 0;i < n - 1;i++)
{
bool exchange = true;
for (int j = 0;j < n - 1 - i;j++)
{
if (a[j] > a[j + 1])
{
Swap(&a[j], a[j + 1]);
exchange = false;
}
}
if (exchange)
{
break;
}
}
}插入排序与冒泡排序算法性能比较分析
插入排序与冒泡排序时间复杂度都是经典的O(N^2)，但插入更优一点，这时就要关注细节了~
结论：插入排序比冒泡排序适应性更强，尤其是当大部分数据有序，局部无序的时候，插入排序相比冒泡排序优势就显现出来了~
四、堆排序
堆排序在我的博客《独树一帜的完全二叉树---堆》已经详细讲解过了，这里只给出核心代码
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child+1 < n && a[child] < a[child + 1])
{
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, n, i);
}
//向下调整
int end = n - 1;
while (end >= 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}五、选择排序
思想：每一轮待排序数据中选出最小的数据，依次放在最左边
第1趟遍历：选出最小放在a[0]位置；第2趟遍历：选出次小放在a[1]位置；依次类推~
void SelectSort(int* a, int n)
{
for (int i = 0;i < n;i++)
{
int mini = i;
for (int j = i + 1;j < n;j++)
{
if (a[mini] > a[j])
{
mini = j;
}
}
Swap(&a[mini], &a[i]);
}
}选择排序优化：每次都要遍历一趟，找出了小的，不妨也把大的找出来，小的放左边，大的放右边
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)
{
int mini = begin;
int maxi = end;
//该循环确定每一趟中的最大值下标和最小值下标
for (int i = begin;i <= end;i++)
{
if (a[mini] > a[i])
{
mini = i;
}
if (a[maxi] < a[i])
{
maxi = i;
}
}
//循环结束后应该交换最小值和begin位置元素,交换最大值和end位置元素
Swap(&a[begin], &a[mini]);
Swap(&a[end], &a[maxi]);
//缩小区间范围
begin++;
end--;
}
}避坑：当maxi和begin位置的值重合时，上述代码有问题
改进方法：在mini和begin位置元素交换完之后修正一下即可
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)
{
int mini = begin;
int maxi = end;
//该循环确定每一趟中的最大值下标和最小值下标
for (int i = begin;i <= end;i++)
{
if (a[mini] > a[i])
{
mini = i;
}
if (a[maxi] < a[i])
{
maxi = i;
}
}
//循环结束后应该交换最小值和begin位置元素,交换最大值和end位置元素
Swap(&a[begin], &a[mini]);
//处理特殊情况---maxi和begin重叠
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
//缩小区间范围
begin++;
end--;
}
}
选择排序时间复杂度：O(N^2)
选择排序在实际中没有太多应用，没有自己的一技之长~
六、快速排序
第一层境界：递归实现(三大版本)
版本一：hoare版本
被称为二叉树结构的快速排序---实际并非二叉树，只是递归过程类似二叉树结构，并且所有操作都是在原数组上进行的(以下图示多个数组只是为了形象展示过程)
思想：
纵观全局：随机选取一个基准值key，再使得key的左区间值均小于key,右区间值均大于key。如此key值就被调整到了正确位置，接下来对左右区间进行相同的操作，显然就是递归调用函数了~
庖丁解牛：如何让每一个区间选取的key来到正确位置呢？(注:hoare版本的key一般都选取区间左端点值或右端点值),下面以key取区间左端点为例
接下来整个数组将被分成三部分：[begin,keyi-1] keyi [keyi+1, end]，对左右区间进行递归~
代码：(以下代码存在问题)
int PartSort1(int* a, int left, int right)
{
int keyi = left;
while (left < right)
{
while (a[right] > a[keyi])
{
right--;
}
while (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)
{
//结束条件两种情况
//1.区间长度为0，代表只剩下一个数据
//2.区间不存在
if (begin >= end)
{
return;
}
int keyi = PartSort1(a, begin, end);
//区间划分:[begin,keyi-1] && keyi && [keyi+1, end]
//递归
PartSort1(a, begin, keyi - 1);
PartSort1(a, keyi + 1, end);
}细节阐释：递归的结束条件：
当区间中只有一个数时就不需要排序了，即begin == end
当区间不存在时也应该结束递归 即begin > end
避坑：
坑1：left起始位置可以是begin+1(×)
因此left下标必须从begin开始，不能从begin+1开始
但是代码仍存在问题，以下是某些特殊情况的分析(坑2与坑3)
坑:2：死循环
填坑：>改>= , <改 <=
坑3：越界
一波刚平，一波又起，就在刚在填了坑1和坑2之后坑3就产生了，下标有可能会越界
填坑：内层while循环加入left与right大小判断
到此为止，坑就填完了，代码也已经全部正确~
int PartSort1(int* a, int left, int right)
{
int keyi = left;
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)
{
//结束条件两种情况
//1.区间长度为0，代表只剩下一个数据
//2.区间不存在
if (begin >= end)
{
return;
}
int keyi = PartSort3(a, begin, end);
//区间划分:[begin,keyi-1] && keyi && [keyi+1, end]
//递归
PartSort3(a, begin, keyi - 1);
PartSort3(a, keyi + 1, end);
}
hoare版本难点分析：
问：当left和right相遇之后，会交换a[left]和a[keyi]，如何保证相遇位置的值一定比a[keyi]要小？
答：当keyi取的是区间左端点的时候，要让right先走，同理，当keyi取的是区间右端点的时候，要让left先走
证明：(以keyi选取左端点下标为例)
left和right相遇，只有两种情况：
1. right处于停止状态，left遇right ;
right停止，说明right遇到了比a[keyi]小的值，此时left遇right, a[left] 就 < a[keyi]
2. left处于停止状态, right遇left ;
right遇left，则在相遇的这一轮left没有动，left之前可能压根没动或者交换了一些轮次
①left 没动的话，就是keyi的位置，那么right也就来到了keyi位置，自己和自己交换结果不受影响
②交换了一些轮次的话，则left始终存储了比keyi小的值~
版本二：挖坑法(更好理解，"坑"也更少)---hoare版本的变形---代码大同小异
为什么说挖坑法更好理解，因为整个过程left和right其中一个必然是坑，无论是right找到了小，还是left找到了大，直接填坑即可，然后形成新的坑~
代码：
int PartSort2(int* a, int left, int right)
{
int key = a[left];
int hole = left;
while (left < right)
{
while (left < right && a[right] >= key)
{
right--;
}
a[hole] = a[right];
hole = right;
while (left < right && a[left] <= key)
{
left++;
}
a[hole] = a[left];
hole = left;
}
a[hole] = key;
return hole;
}
void QuickSort(int* a, int begin, int end)
{
//结束条件两种情况
//1.区间长度为0，代表只剩下一个数据
//2.区间不存在
if (begin >= end)
{
return;
}
int keyi = PartSort2(a, begin, end);
//区间划分:[begin,keyi-1] && keyi && [keyi+1, end]
//递归
PartSort2(a, begin, keyi - 1);
PartSort2(a, keyi + 1, end);
}
版本三：前后指针法(最推荐的版本)---天才设想
第一轮操作如下图所示，后序仍然是递归调用自己~
前后指针法本质分析：
无论a[cur]与a[keyi]大小关系如何，cur一直向后走；而a[cur]<a[keyi]时，prev才向后走，a[cur]>=a[keyi]时，prev不动，只有cur向后走
这就导致如果prev和cur中间间隔数据，那么这些数据必然比a[keyi]要大，因此当cur遇到比a[keyi]小的数据就交换prev后面一个数据和当前cur的值，使得小数换到前面，大数去到后面, 所以大数会跳跃式的往后移动，小数也会跳跃式的往前移动~
当cur越界跳出循环时，prev前面的所有值就都比a[keyi]小了，再交换a[prev]与a[keyi]，就使得左区间<a[keyi], 右区间>a[key],继续递归即可
代码实现
int PartSort3(int* a, int left, int right)
{
int prev = left;
int cur = left + 1;
int keyi = left;
while (cur <= right)
{
if(a[cur] < a[keyi])
{
prev++;
Swap(&a[prev], &a[cur]);
}
//更好的if写法
if(a[cur] < a[keyi] && ++prev != cur) //自己和自己交换没有意义
{
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[keyi], &a[prev]);
return prev;
}
void QuickSort(int* a, int begin, int end)
{
//结束条件两种情况
//1.区间长度为0，代表只剩下一个数据
//2.区间不存在
if (begin >= end)
{
return;
}
int keyi = PartSort3(a, begin, end);
//区间划分:[begin,keyi-1] && keyi && [keyi+1, end]
//递归
PartSort3(a, begin, keyi - 1);
PartSort3(a, keyi + 1, end);
}
以上三个版本代码缺陷：
主要体现在选key上，我们默认都是区间左端点值做key，但是当数组有序的时候每次左区间不存在，右区间长度减少1，因此时间复杂度就是标准的等差数列---O(N^2)，效率低下~
快速排序递归版本选key优化
1.三数取中：区间的左端点值，右端点值，中间位置的值三个数中选大小适中的数作为key
三数取中代码实现：
int GetMidIndex(int* a, int left, int right)
{
int midi = (left + right) / 2;
if (a[left] < a[midi])
{
if (a[midi] < a[right])
{
return midi;
}
else if (a[left] < a[right])
{
return right;
}
else
{
return left;
}
}
else//a[left] > a[midi]
{
if (a[midi] > a[right])
{
return midi;
}
else if (a[left] > a[right])
{
return right;
}
else
{
return left;
}
}
}三个版本在函数开始加上这两句代码就实现了三数取中的优化方案~
2.随机数选key---三数取中进一步优化
int GetMidIndex(int* a, int left, int right)
{
int midi = left + (rand() % (right - left));
if (a[left] < a[midi])
{
if (a[midi] < a[right])
{
return midi;
}
else if (a[left] < a[right])
{
return right;
}
else
{
return left;
}
}
else //a[left] > a[midi]
{
if (a[midi] > a[right])
{
return midi;
}
else if (a[left] > a[right])
{
return right;
}
else
{
return left;
}
}
}
3.三路划分---专门解决快速排序遇到有大量重复元素的问题
大量重复元素会导致什么问题呢？
大量重复元素导致的问题和数组有序导致的问题有异曲同工之处，都是每次右区间长度只减少1，导致了时间复杂度是标准的等差数列---O(N^2）,而三路划分可以解决这个问题
三路划分：
三路划分核心逻辑：
1.a[cur]<key，交换a[cur]和a[left]，++left,++cur
2.a[cur]>key，交换a[cur]和a[right]，--right
3.a[cur] == key ,++cur
理解：left一直指向了key的位置，而整个过程本质是把left甩左边，right甩右边，把和key相等的值往中间推的过程
代码：
//三路划分实现快排
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
int left = begin;
int right = end;
int cur = left + 1;
int key = a[left];
while (cur <= right)
{
if (a[cur] < key)
{
Swap(&a[left], &a[cur]);
++left;
++cur;
}
else if (a[cur] > key)
{
Swap(&a[right], &a[cur]);
--right;
}
else
{
cur++;
}
}
//子区间
//[begin, left-1], [left, right], [right+1, end]
//递归调用
QuickSort(a, begin, left - 1);
QuickSort(a, right + 1, end);
}ps:三路划分中key的选取同样可以采用随机数选key来实现
第二层境界：非递归实现(借助栈)
"梅须逊雪三分白，雪却输梅一段香"，快速排序递归法外强中干，却有着栈溢出的风险~，高手写代码，能用非递归，不用递归~
递归无非也是在递归每段区间罢了，利用栈的后进先出，我们同样可以采用循环处理每段区间
思想：每次从栈里面拿出一段区间，单趟分割处理，左右区间入栈
用栈处理区间实现快速排序过程示意图
四大问题：
1.一段区间如何入栈？
答：分成右端点和坐端点依次入栈即可(左端点先入栈，右端点后入栈也可以)
2.一个区间划分为左右区间后哪个区间先入栈？
答：都可以，就看你想先处理左区间还是想先处理右区间
先处理左区间---右区间先入栈；先处理右区间---左区间先入栈；
3.什么时候压栈结束？
答：当区间左端点>=右端点，即不需要再划分区间也就不需要区间入栈了
4.什么时候循环结束？
答：栈为空
代码(以先处理左区间为例)---栈的实现参考我的博客《别样的数据结构---栈》
#include"Sort.h"
#include"Stack.h"
void PrintArray(int* a, int n)
{
for (int i = 0;i < n;i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
int PartSort3(int* a, int left, int right)
{
int keyi = left;
int prev = left;
int cur = left + 1;
while (cur <= right)
{
if (a[cur] < a[keyi])
{
prev++;
Swap(&a[cur], &a[prev]);
}
cur++;
}
Swap(&a[prev], &a[keyi]);
return prev;
}
void QuickSortNonR(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 = PartSort3(a, left, right);
if (keyi+1 < right)
{
STPush(&st, right);
STPush(&st, keyi + 1);
}
if (left < keyi - 1)
{
STPush(&st, keyi-1);
STPush(&st, left);
}
}
STDestroy(&st);
}快速排序复杂度分析
1.时间复杂度：
最好：每次找到的key都是中位数，快排过程的逻辑结构就是完美的二叉树---O(N*logN)
最坏：数组有序(若选取左端点做key）---O(N^2)
按理来说时间复杂度是按照最坏情况来算的,但是快排的时间复杂度是O(N*logN)，因为我们一般不会直接选取左端点选key，而是采取随机数选k或者三数取中进行了优化
2.空间复杂度：
O(logN)---递归调用消耗logN层栈帧
七、归并排序
第一层境界：递归实现
思想：数组一分为二，整体有序则需左右有序，左右有序则递归即可~
其实归并排序的思想本质就是二叉树遍历方法中后序的思想---左右子树遍历完才遍历根
那么“归并”二字体现在哪？就体现在左右区间有序之后的合并过程从而使整体有序
而归并肯定要新建一个数组，归并好了之后拷贝回原数组，直接在原数组归并会产生覆盖值的问题
代码：
//归并排序递归实现
void _MergeSort(int* a, int begin, int end, int* tmp)
{
//begin不可能>end
if (begin == end)
{
return;
}
//分割区间
int mid = (begin + end) / 2;
//[begn,mid] [mid + 1, end]
//递归
_MergeSort(a, begin, mid, tmp);
_MergeSort(a, mid + 1, end, tmp);
//归并
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int i = begin;
//取小的尾插
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[i++] = a[begin1++];
}
else
{
tmp[i++] = a[begin2++];
}
}
//有一个走完了，还有一个没走完
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = a[begin2++];
}
//拷贝数据
memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}代码要点：
1.递归结束条件：begin == end ，也就是区间只有一个数；begin不可能>end, 因为区间划分是[begin, mid] [mid+1, end] ，而mid=(begin+end) / 2 , 当begin和end相等时mid最大等于end，而此时就是区间只有一个数的情况，已经不需要再分了
2.memcpy函数要注意src和dest位置，因为每次二分区间之后区间下标不一定是从0开始；还要注意数据个数，不是i, i是单纯的下标，应该用end-begin+1来算
归并排序复杂度分析：
时间复杂度：O(N*logN)---完美的二叉树
空间复杂度：O(N) 开辟tmp数组：O(N) ; 递归调用：O(logN) 总共：O(N+logN)---O(N)
归并排序递归优化版本：小区间优化
归并排序每次都是把区间一分为二，然后递归，但是慢慢到后面，一个区间数据就很少了，这时仍然去递归调用归并排序效率就比较低了，这时可以调用插入排序函数解决剩下的排序~
区间长度小于多少开始调用插入函数不是固定的，一般取10差不多
进阶理解：可以看到，最下面三层递归调用次数占了总次数的87.5%，而倒数第四层每组数据差不多就是10个，因此没必要再提前调用插入函数了，意义不大~
第二层境界：非递归实现(循环实现)
思路：通过控制归并每组数据个数gap的值，实现不断地归并，直至整个数组有序
代码建立一：gap取特定值时归并实现
好风凭借力，送我上青天~，cv一下归并核心代码
注意归并的两组数据每组数据是gap个，因此归并的两段区间begin与end位置要注意改一改(画图)
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail\n");
return;
}
//gap表示要归并的两个组的每个组的数据个数
//gap ==1 表示一一归
int gap = 1;
int j = 0;
for (int i = 0; i < n;i+=2*gap)
{
//每组数据的归并
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end1)
{
tmp[j++] = a[begin2++];
}
}
}代码建立二：控制gap变化实现归并排序
//归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail\n");
return;
}
//gap表示要归并的两个组的每个组的数据个数
//gap ==1 表示一一归
int gap = 1;
while (gap < n)
{
int j = 0;
for (int i = 0; i < n;i += 2 * gap)
{
//每组数据的归并
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
}
//每合并一次把数据拷贝回原数组
memcpy(a, tmp, sizeof(int) * n);
gap *= 2;
}
free(tmp);
}
8个数据测试确实没有问题，但是当测试9个数据，10个数据的时候，程序直接崩溃了
错误分析：越界问题，只要当数据个数不是2^N次方都会越界~
打印区间下标分析越界情况：
错误解决方案1：遇到越界情况直接break跳出for循环
错误原因：因为最后要把tmp数组拷贝回a数组，如果直接break跳出循环，则tmp数组最后面数据就是随机值了，拷贝回原数组，不但后面数据没有排序，还覆盖了原数据
正确解决方案1：归并一段，拷贝一段
无非就是要处理越界的三种情形，可以发现，情形1,2属于一类，都是要归并的右区间整个不在数组范围内，压根不需要归并，直接break即可；而情形3的右区间部分越界，因此我们重新修正一下边界end2取值，使其等于数组最后一个数据下标即可(n-1),然后归并之后往回拷贝时只拷贝在数组的那一段就行
ps:归并的两数组并没有要求数据个数相同~
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail\n");
return;
}
//gap表示要归并的两个组的每个组的数据个数
//gap ==1 表示一一归
int gap = 1;
while (gap < n)
{
int j = 0;
for (int i = 0; i < n;i += 2 * gap)
{
//每组数据的归并
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
//处理越界情况1、2
if (end1 >= n || begin2 >= n)
{
break;
}
//处理越界情况3
//修正end2边界
if (end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
//每归并一段，就拷贝该段到原数组
memcpy(a+i, tmp+i, sizeof(int) * (end2 - i + 1));
}
gap *= 2;
}
free(tmp);
}错误解决方案2:仍采用归并完一趟后整体拷贝的方法，若越界，则修正边界到n-1
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail\n");
return;
}
//gap表示要归并的两个组的每个组的数据个数
//gap ==1 表示一一归
int gap = 1;
while (gap < n)
{
int j = 0;
for (int i = 0; i < n;i += 2 * gap)
{
//每组数据的归并
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
if (end1 >= n)
{
end1 = n - 1;
begin2 = n - 1;
end2 = n - 1;
}
else if (begin2 >= n)
{
begin2 = n - 1;
end2 = n - 1;
}
else if (end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
}
memcpy(a, tmp, sizeof(int) * n);
gap *= 2;
}
free(tmp);
}打印边界下标分析错误原因：
正确解决方案2：修正边界，直接使得右区间不存在，就不会执行归并相关逻辑代码，直接把第一个区间数据拷依次拷贝到tmp中
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail\n");
return;
}
//gap表示要归并的两个组的每个组的数据个数
//gap ==1 表示一一归
int gap = 1;
while (gap < n)
{
int j = 0;
for (int i = 0; i < n;i += 2 * gap)
{
//每组数据的归并
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
if (end1 >= n)
{
end1 = n - 1;
begin2 = n;
end2 = n - 1;
}
else if (begin2 >= n)
{
begin2 = n;
end2 = n - 1;
}
else if (end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
}
memcpy(a, tmp, sizeof(int) * n);
gap *= 2;
}
free(tmp);
}
归并排序的硬伤在于数据拷贝~
归并排序复杂度
时间复杂度:O(N*logN)
空间复杂度:O(N)
八、计数排序
计数排序相比其他七大排序就比较特别了，因为其他七大排序都用到了数据的比较，也就是数据都要比大小，但是计数排序的实现不用比较数据大小，计数就是统计数据出现个数
步骤：
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] < min)
{
min = a[i];
}
if (a[i] > max)
{
max = a[i];
}
}
int range = max - min + 1;
int* countA = (int*)malloc(sizeof(int) * range);
memset(a, 0, sizeof(int) * range);
//统计次数
for(int i = 0;i<n;i++)
{
countA[a[i] - min]++;
}
//排序
int k = 0;
for (int j = 0;j < range;j++)
{
while (countA[j]--)
{
a[k++] = j + min;
}
}
}
计数排序复杂度分析：
时间复杂度：O(N+range) --- 当N >> range --- O(N)
空间复杂度：O(Range)
计数排序缺陷：
缺陷1：依赖数据范围，适用于范围集中的数组
缺陷2：只能用于整形数据排序
九、八大排序总结
问世间情为何物，不过是一物降一物，除了及个别排序外，剩下的排序都是各有千秋的~
比较排序具有普适性，可以适用于任意数据样本，而非比较排序---计数排序就比较挑剔了~
排序稳定性：
简单来说，数组中有若干相同的值，排序完之后这些相同的值前后位置保持不变，就说该排序是稳定的，否则就是不稳定的
稳定性意义何在？值不都相同嘛，在前在后有意义吗？当然有！
比如说考试3个同学成绩相同，那么根据交卷时间前后就可以分出一二三等奖~
再比如说两个同学总分相同，但语文成绩高低不同，这时要排名的话，可以先按照语文成绩排序，然后采用一个稳定的排序算法对总分排序，那么总分相同的同学排名高低立现~
本篇博客关于排序算法的分享就到这了，日拱一卒无有尽，功不唐捐终入海，不弃微末，久久为功，欢迎大家交流指正~
794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
