文章目录
希尔排序（Shell Sort）是插入排序的一种高效改进版本，也称为缩小增量排序。它通过将原始数组分成多个子序列进行插入排序，逐步缩小子序列的间隔（增量），最终对整个数组进行一次插入排序，从而显著提高排序效率。
核心思想
1、分组插入排序：将原始数组按一定间隔（增量）分成若干子序列，对每个子序列进行插入排序。
2、逐步缩小增量：每次排序后减小增量，重复分组和插入排序，直到增量为1（此时相当于普通插入排序，但数组已基本有序）。
算法步骤
1、选择增量序列：初始增量通常为数组长度的一半，之后每次减半（如 gap = n/2, gap/2, ..., 1）。
2、分组插入排序：
对每个增量 gap，将数组分为 gap 个子序列（例如，gap=3 时，子序列为 [arr[0], arr[3], arr[6], ...]、[arr[1], arr[4], arr[7], ...] 等）。
对每个子序列进行插入排序。
3、终止条件：当增量缩小至1时，完成最后一次插入排序，数组有序。
代码实现
bash
#include <stdio.h>
void shellSort(int arr[], int n) {
// 初始增量设为数组长度的一半，逐步缩小
for (int gap = n / 2; gap > 0; gap /= 2) {
// 对每个子序列进行插入排序
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j;
// 插入排序：将arr[i]插入到子序列的正确位置
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}
int main() {
int arr[] = {12, 34, 54, 2, 3, 8, 19};
int n = sizeof(arr) / sizeof(arr[0]);
printf("排序前: ");
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
shellSort(arr, n);
printf("\n排序后: ");
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
return 0;
}执行过程示例
初始状态
数组：[12, 34, 54, 2, 3, 8, 19]
长度 n = 7，初始增量 gap = 7/2 = 3（整数除法）。
第一轮排序（gap=3）
1、子序列分组：
子序列1（索引 0, 3, 6）：12, 2, 19
子序列2（索引 1, 4）：34, 3
子序列3（索引 2, 5）：54, 8
2、对每个子序列进行插入排序：
子序列1：12, 2, 19
插入 2：2, 12, 19（2 插入到 12 前）
插入 19：已有序，无需移动
排序后：[2, 12, 19]
子序列2：34, 3
插入 3：3, 34（3 插入到 34 前）
排序后：[3, 34]
子序列3：54, 8
插入 8：8, 54（8 插入到 54 前）
排序后：[8, 54]
本轮排序后数组：
2, 3, 8, 12, 34, 54, 19
第二轮排序（gap=1）
此时 gap = 3/2 = 1，进行标准插入排序（对整个数组）。
逐步插入过程：
i=1：元素 3，已比 2 大，无需移动 → [2, 3, 8, 12, 34, 54, 19]
i=2：元素 8，已比 3 大，无需移动 → 同上
i=3：元素 12，已比 8 大，无需移动 → 同上
i=4：元素 34，已比 12 大，无需移动 → 同上
i=5：元素 54，已比 34 大，无需移动 → 同上
i=6：元素 19，需插入到 12 后：
比较 19 和 54：19 < 54 → 移动 54 到 19 的位置
比较 19 和 34：19 < 34 → 移动 34 到 54 的位置
比较 19 和 12：19 > 12 → 停止，插入到 12 后
数组变为：[2, 3, 8, 12, 19, 34, 54]
最终排序结果：
2, 3, 8, 12, 19, 34, 54
特点
1、增量选择：希尔排序的性能依赖于增量序列的选择。常见序列有：
n/2, n/4, ..., 1（简单但非最优）。
Hibbard序列（1, 3, 7, ..., 2^k-1）。
Sedgewick序列（更复杂但更高效）。
2、稳定性：希尔排序是不稳定的（相同元素可能因增量跨步而改变相对顺序）。
优缺点
优点：
1、比简单插入排序快得多，尤其对中等规模数组。
2、不需要额外空间（原地排序）。
缺点：
1、时间复杂度不稳定，依赖增量序列。
2、不稳定排序（可能改变相同元素的顺序）。
适用场景
1、数据量中等（如几千到几万元素）。
2、对内存使用敏感（无需额外空间）。
3、不需要稳定排序时。