1.排序的概念及分类
排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作
常见的排序算法可以按如图所示分类。
以下所有的排序算法均以升序的方式实现。
2.插入排序
2.1 直接插入排序（InsertSort）
直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
简单来说，平常玩的扑克牌游戏就是一种插入排序。
排序原理：
当插入第 i ( i >= 1 ) 个元素时，前面的 array[0] ，array[1] ，… ，array[i-1] 已经排好序，此时用 array[i] 的排序码与 array[i - 1] ，array[i - 2] ，… 的排序码顺序进行比较，找到插入位置即将 array[i] 插入，原来位置上的元素顺序后移。
💻排序实现：
void InsertSort(int* a, int n) {
for (int i = 1; i < n; ++i) {
int end = i - 1;
int tmp = a[i];
while (end >= 0) {
if (tmp < a[end]) {
a[end + 1] = a[end];
--end;
} else {
break;
}
}
a[end + 1] = tmp;
}
}
⌨️代码解读：
- 第一个
for循环指的是从第一个数开始依次往后遍历，end指向已排序部分的最后一个元素（即开始的a[0]），tmp = a[i]提前保存该位置的数据，避免移动时的覆盖消除该数据。 - 从后往前遍历已排序部分，找到合适的插入位置，如果当前要插入的元素小于已排序部分的元素，将已排序部分的元素后移一位，
--end继续向前比较；如果找到合适的插入位置，break退出循环。 - 找到合适位置后，
a[end + 1] = tmp将当前要插入的元素插入到合适的位置。
🖱️复杂度分析：
• 时间复杂度：
○ **最好情况：**数组已经是有序的，此时内层的 while 循环每次只需要比较一次就会退出，时间复杂度为 O(n)。
○ **最坏情况：**数组是逆序的，内层的 while 循环每次都需要比较到已排序部分的第一个元素，时间复杂度为 O(n²)。
○ **平均情况：**时间复杂度为 O(n²)。
• 空间复杂度：O(1)。
**总结：**元素集合越接近有序，直接插入排序算法的时间效率越高。
2.2 希尔排序（ShellSort）
希尔排序又称缩小增量法。其基本思想是：先选定一个整数 gap ，把待排序文件中所有记录分成多个组，所有距离为 gap 的记录分在同一组内，并对每一组内的记录进行排序。然后，取新的 gap ，重复上述分组和排序的工作。当到达 gap = 1 时，所有记录在统一组内排好序。
相同颜色的数字为同一组。
💻排序实现：
**版本 1：**按组分配排序
void ShellSort(int* a, int n) {
int gap = n;
for (int j = 0; j < gap; j++) {
gap /= 2;
for (int i = j; i < n - gap; i += gap) {
int end = i;
int tmp = a[i + gap];
while (end >= 0) {
if (tmp < a[end]) {
a[end + gap] = a[end];
end -= gap;
} else {
break;
}
a[end + gap] = tmp;
}
}
}
}
**版本 2：**依次排序
void ShellSort(int* a, int n) {
int gap = n;
while (gap > 1) {
gap /= 2;
// gap = n / 3 + 1;
for (int i = 0; i < n - gap; i++) {
int end = i;
int tmp = a[i + gap];
while (end >= 0) {
if (tmp < a[end]) {
a[end + gap] = a[end];
end -= gap;
} else {
break;
}
a[end + gap] = tmp;
}
}
}
}
⌨️代码解读：
希尔排序其实和插入排序是十分相似的，希尔排序是对直接插入排序的优化，只不过是每间隔 gap 个数进行排序，插入排序间隔是 1 ，通过多次 gap 的改变，多次的分组排序最终能趋向于有序。
🔥值得注意的是：
for循环中i < n - gap是因为排完序后剩下的数根据gap的大小，剩下的数已经自动有序了。gap /= 2和gap = n / 3 + 1都是可以的，并没有严格的限制。tmp一直在end的下一个位置，插入的位置一直在end的下一个位置。- 当
gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。 - 希尔排序的时间复杂度不好计算，因为
gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定。
《数据结构(C语言版)》— 严蔚敏：
🖱️复杂度分析：
• 时间复杂度：
○ **最好情况：**数组已经是有序的，时间复杂度为 O(n)。
○ **最坏情况：**数组是逆序的，时间复杂度为 O(n²)。
○ **平均情况：**时间复杂度大约为 O(n^1.3)。
• 空间复杂度：O(1)。
**总结：**希尔排序是不稳定的。
3.选择排序
3.1 直接选择排序（SelectSort）
直接选择排序可以说是最简单的一种排序了，其基本思想为：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
排序原理：
- 在元素集合
array[i]–array[n-1]中选择关键码最大 (小) 的数据元素。 - 若它不是这组元素中的最后一个 (第一个) 元素，则将它与这组元素中的最后一个（第一个）元素交换。
- 在剩余的
array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素。
💻排序实现：
void Swap(int* p1, int* p2) {
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void SelectSort(int* a, int n) {
int left = 0, right = n - 1;
while (left < right) {
int mini = left, maxi = right;
for (int i = left; i <= right; ++i) {
if (a[i] < a[mini]) {
mini = i;
}
if (a[i] > a[maxi]) {
maxi = i;
}
}
Swap(&a[left], &a[mini]);
// 如果 left 和 maxi 重叠，交换后修正一下
if (left == maxi) {
maxi = mini;
}
Swap(&a[right], &a[maxi]);
++left;
--right;
}
}
⌨️代码解读：
mini初始化为left，maxi初始化为right，用于记录当前未排序部分的最小值和最大值的索引。- 通过
for循环从left到right遍历数组，比较每个元素与a[mini]和a[maxi]的大小，如果发现更小的元素则更新mini，如果发现更大的元素则更新maxi。 - 调用
Swap函数将最小值a[mini]交换到左边界a[left]的位置，最大值a[maxi]交换到右边界a[right]的位置。 ++left和--right分别将左边界右移和右边界左移，缩小未排序部分的范围。
🔥**值得注意的是：**如果 left 恰好等于 maxi，说明在交换最小值时，最大值的位置已经被交换到了 mini 处，所以需要将 maxi 更新为 mini。
🖱️复杂度分析：
• 时间复杂度：
○ **最好情况：**即使数组已经有序，每一轮仍然需要遍历未排序部分来确定最小值和最大值的位置，时间复杂度为 O(n)。
○ **最坏情况：**当数组是逆序排列时，同样需要进行完整的遍历和交换操作，时间复杂度为 O(n²)。
○ **平均情况：**时间复杂度为 O(n²)。
• 空间复杂度：O(1)。
**总结：**直接选择排序思考非常好理解，但是效率不是很好，实际中很少使用。
3.2 堆排序（HeapSort）
堆排序是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
在堆的专题章节已经有详细的分析了，这里就不过多讲解。
**总结：**堆排序使用堆来选数，效率就高了很多。