原始数据分成多个子序列，对每个子序列进行插入排序，逐步使数据接近有序，最终对整个序列进行插入排序达到完全有序

原创已于 2025-06-01 13:43:42 修改 · 656 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #算法 #数据结构

于 2025-06-01 13:39:10 首次发布

Structured(design engineering) 同时被 3 个专栏收录

486 篇文章

订阅专栏

Design pattern(case analysis)

142 篇文章

订阅专栏

UML(Introduction to Systems)

131 篇文章

订阅专栏

希尔排序算法解析

基本思想概述
希尔排序是一种改进的插入排序算法。它通过将原始数据分成多个子序列，对每个子序列进行插入排序，逐步使数据接近有序，最终对整个序列进行插入排序达到完全有序。其核心在于设置不同的步长（增量），让元素可以大跨度地移动，提前把数据“粗调”到较有序状态，减少直接插入排序时的比较和移动次数。
步骤详解
- 步骤1：构造步长序列
  - 步长序列的起始值 delta1 设为数组长度 n 的一半，即 delta1 = n/2 。后续每个 deltak 是前一个的 1/2 ，直到 deltak = 1 。例如，若数组长度 n = 16 ，那么步长序列依次为 8、4、2、1 。这样设置步长的目的是先进行“宏观”上的排序，让元素能快速移动到大致正确位置，随着步长逐渐减小，排序越来越精细。
- 步骤2：k趟排序
  依据构造好的步长序列，依次进行多趟排序。每一趟排序都使用当前对应的步长，对序列进行处理。比如第一趟步长为 n/2 ，就按照这个步长对数组元素分组并处理；第二趟步长变为 n/4 ，再按新步长操作，直到步长为 1 。
- 步骤3：组内直接插入排序
  对于每一趟排序，按照当前步长 delta ，将等步长位置的元素分为一组。例如步长为 4 时，数组 [a0, a1, a2, a3, a4, a5, a6, a7] 会分成 [a0, a4]、[a1, a5]、[a2, a6]、[a3, a7] 这几组。然后在每一组内，在原位置上进行直接插入排序。直接插入排序的基本操作是将一个数据插入到已经排好序的子序列中的适当位置。当步长为 1 时，其实就是普通的直接插入排序，此时由于前面多趟排序已经让数据接近有序，所以效率比一开始就进行直接插入排序要高很多。

示例代码（Python）

def shell_sort(arr):
    n = len(arr)
    delta = n // 2
    while delta > 0:
        for i in range(delta, n):
            temp = arr[i]
            j = i
            while j >= delta and arr[j - delta] > temp:
                arr[j] = arr[j - delta]
                j -= delta
            arr[j] = temp
        delta //= 2
    return arr

可以通过以下方式调用：

arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_arr = shell_sort(arr)
print(sorted_arr)

希尔排序的时间复杂度平均为 $O(n^{1.3})$ 左右，空间复杂度为 $O (1)$ ，它在处理大规模数据时比直接插入排序效率更高。
图片内容描述了希尔排序算法的基本思想和步骤。希尔排序是一种基于插入排序的算法，通过引入间隔序列来对数组进行分组，然后在这些组内进行插入排序，逐步减小间隔，直到整个数组有序。具体步骤如下：

构造步长序列：创建一个步长序列 delta，其中 delta1 = n/2，后续的每个 delta 是前一个的一半，直到 deltak = 1。这里的 n 是数组的长度。
进行k趟排序：根据步长序列，进行 k 趟排序，每一趟使用一个不同的步长。
分组排序：在每一趟排序中，根据当前的步长 delta，将数组中的元素按照步长分组，然后在每个组内进行直接插入排序。

希尔排序通过这种方式逐步减少步长，最终实现整个数组的有序排列。这种方法比简单的插入排序更高效，因为它在初始阶段可以进行更大幅度的“跳跃”，从而更快地将数组中的元素移动到接近最终位置。
以下以数组 arr = [9, 1, 5, 8, 3, 7, 4, 6, 2] 为例，说明希尔排序算法执行过程：

1. 构造步长序列并开始排序

数组长度 n = 9 ，初始步长 delta1 = n // 2 = 4 。

2. 第一趟排序（步长 `delta = 4` ）

将数组按下标间隔为 4 分组：

第一组：[9, 3] ，比较 9 和 3 ，因为 9 > 3 ，交换位置，得到 [3, 1, 5, 8, 9, 7, 4, 6, 2] 。
第二组：[1, 7] ，1 < 7 ，不交换。
第三组：[5, 4] ，5 > 4 ，交换，得到 [3, 1, 4, 8, 9, 7, 5, 6, 2] 。
第四组：[8, 6] ，8 > 6 ，交换，得到 [3, 1, 4, 6, 9, 7, 5, 8, 2] 。
第五组：[3, 2] ，3 > 2 ，交换，得到 [3, 1, 4, 6, 2, 7, 5, 8, 9] 。

3. 第二趟排序（步长 `delta = 4 // 2 = 2` ）

按步长 2 分组：

第一组：[3, 4, 2, 5, 9] ，从第二个元素 4 开始，4 < 3 ，交换，得到 [4, 1, 3, 6, 2, 7, 5, 8, 9] ；继续处理，2 < 4 ，交换，2 < 3 ，交换，得到 [2, 1, 3, 6, 4, 7, 5, 8, 9] ；5 > 2 ，不交换；9 > 2 ，不交换。
第二组：[1, 6, 7, 8] ，元素间比较后均不交换。
第三组：[3, 4, 5] ，元素间比较后均不交换。

4. 第三趟排序（步长 `delta = 2 // 2 = 1` ，即普通插入排序）

从第二个元素 1 开始，1 < 2 ，将 1 向前插入，得到 [1, 2, 3, 6, 4, 7, 5, 8, 9] ；继续对后续元素操作，6 > 2 ，不交换；4 < 6 ，将 4 向前插入合适位置，得到 [1, 2, 3, 4, 6, 7, 5, 8, 9] ；5 < 6 ，将 5 向前插入，得到 [1, 2, 3, 4, 5, 7, 6, 8, 9] ；6 < 7 ，不交换；8 > 7 ，不交换；9 > 8 ，不交换。最终排序结果为 [1, 2, 3, 4, 5, 6, 7, 8, 9] 。
图片内容描述了希尔排序算法的基本思想和步骤。希尔排序是一种基于插入排序的算法，通过引入间隔序列来对数组进行分组，然后在这些组内进行插入排序，逐步减小间隔，直到整个数组有序。具体步骤如下：

构造步长序列：创建一个步长序列 delta，其中 delta1 = n/2，后续的每个 delta 是前一个的一半，直到 deltak = 1。这里的 n 是数组的长度。
进行k趟排序：根据步长序列，进行 k 趟排序，每一趟使用一个不同的步长。
分组排序：在每一趟排序中，根据当前的步长 delta，将数组中的元素按照步长分组，然后在每个组内进行直接插入排序。

希尔排序通过这种方式逐步减少步长，最终实现整个数组的有序排列。这种方法比简单的插入排序更高效，因为它在初始阶段可以进行更大幅度的“跳跃”，从而更快地将数组中的元素移动到接近最终位置。
希尔排序和直接插入排序都是基于比较和交换元素的排序算法，但它们在实现细节和效率上有所不同：

直接插入排序

工作原理：直接插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
时间复杂度：在最坏的情况下（即数组完全逆序），直接插入排序的时间复杂度为 (O(n^2))，其中 (n) 是数组的长度。
空间复杂度：直接插入排序是原地排序，空间复杂度为 (O(1))。
适用场景：适用于小规模数据的排序，或者当输入数组已经接近有序时。

希尔排序

工作原理：希尔排序是插入排序的一种更高效的改进版本。它通过引入间隔序列（步长），将数组分成多个子序列，然后对这些子序列进行直接插入排序。随着算法的进行，间隔逐渐减小，直到为1，此时算法变为一个简单的直接插入排序。
时间复杂度：希尔排序的性能依赖于步长的选取。在最佳情况下，它可以接近 (O(n \log n)) 的时间复杂度，但在最坏的情况下，它仍然可能是 (O(n^2))。
空间复杂度：希尔排序也是原地排序，空间复杂度为 (O(1))。
适用场景：希尔排序适用于中等规模的数据排序，特别是当数据部分有序时，其性能优于直接插入排序。