希尔排序概况

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。该方法因D.L.Shell于1959年提出而得名。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

算法思路

先取一个小于 n 的整数 $d_1$ 作为第一个增量，把文件的全部记录分组。所有距离为 $d_1$ 的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量 $d_{2}<d_{1}$ 重复上述的分组和排序，直至所取的增量 $d_{t}=1(d_{t}<d_{t-1}<\cdots <d_{2}<d_{1})$ ，即所有记录放在同一组中进行直接插入排序为止。

该方法实质上是一种分组插入方法。

图解算法

假设，我们有一个数列，初始状态为 $\left \{ 5,7,8,3,1,2,4,6 \right \}$ ，一共 8 个元素。

第一轮

我们按下标相隔距离为 4 进行分组，这样a[0]与a[4]是一组、a[1]与a[5]是一组、...。如下图所示。

每个分组进行插入排序后，各个分组就变成了有序的，注意整体不一定有序。如下图所示。

第二轮

小增量为上个增量的一半 2，继续划分分组。此时，每个分组元素个数多了，但是，数组变的部分有序了，插入排序效率同样比高。此时的分组情况如下图所示。

对每个分组进行插入排序，使其每个分组各自有序。如下图所示。

第三轮

最后设置增量为上一个增量的一半 1，则整个数组被分为一组，此时，整个数组已经接近有序了，插入排序效率高。如下图所示。

再对分组进行插入排序，使其每个分组各自有序。这样排序完成。

动画展示

我们借用五分钟学算法的gif动图，感谢五分钟学算法。

算法性能

时间复杂度

希尔排序的复杂度和增量序列是相关的。为了保证分组粗调没有盲区，每一轮的增量需要彼此“互质”，也就是没有除1之外的公约数。

$\left \{ 1,2,4,8,\cdots \right \}$ 这种序列并不是很好的增量序列，使用这个增量序列的时间复杂度（最坏情形）是 $O(n^{2})$ 。

Hibbard 提出了另一个增量序列 $\left \{ 1,3,7,\cdots,2^{k}-1 \right \}$ ，通项公式 $2^{k}-1$ ，这种序列的时间复杂度（最坏情形）为 $O(n^{1.5})$ 。

Sedgewick 提出了几种增量序列，其最坏情形运行时间为 $O(n^{1.3})$ ，其中最好的一个序列是 $\left \{ 1,5,9,41,109,\cdots \right \}$ ，通项公式 $9*4^{k}-9*2^{k}+1$ 或者 $4^{k}-3*2^{k}+1$ 。

所以我们认为希尔排序的平均时间复杂度为 $O(nlogn)$ 。

空间复杂度

由于希尔排序使用了插入排序的方法，所以空间复杂度和插入排序相同， $O(1)$ 。

稳定性

不稳定。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。

代码实现

C和C++

void shellSort(int arr[], int len) {
    //计算的序列为1, 4, 13, 40, 121, 364, 1093...
    int gap = 1;
    while (gap < len/3) {
        gap = 3*gap+1;
    }
    
    while (gap >= 1) {
        for (int i=gap; i<len; i++) {
            //对arr[i], arr[i-h], arr[i-2h], ... 使用插入排序
            int e = arr[i];
            int j;
            for (j=i; j>=gap; e<arr[j-gap]; j-=gap) {
                arr[j] = arr[j-gap];
            }
            arr[j] = e;
        }
        gap /= 3;
    }
}

Java

public class ShellSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int gap = 1;
        while (gap < arr.length/3) {
            gap = gap * 3 + 1;
        }

        while (gap > 0) {
            for (int i = gap; i < arr.length; i++) {
                int tmp = arr[i];
                int j = i - gap;
                while (j >= 0 && arr[j] > tmp) {
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                arr[j + gap] = tmp;
            }
            gap = (int) Math.floor(gap / 3);
        }

        return arr;
    }
}

Python

def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    return arr

justidle

发布了138 篇原创文章 · 获赞 7 · 访问量 41万+

私信关注

排序——希尔排序（Shell's sort）