排序算法(四)——希尔排序算法详解及Python实现

一、简介

希尔排序（Shell Sort）算法，属于插入排序类，是不稳定排序，是对直接插入排序算法的优化，其时间复杂度为O(n^3/2)。

希尔排序是D.L.Shell 于1959年提出来的算法，在此之前排序算法的时间复杂度基本上都是O(n²)的，希尔排序是突破这个时间复杂度的第一批算法之一。^[1]

二、算法介绍

直接插入排序算法在1-数组基本有序或2-数组元素较少时效率很高，希尔排序的出发点就是如何对待排序数组进行调整，使其满足上述两个条件，从而利用直接插入排序算法的优势。最终，科学家Shell通过对数组进行分组，分隔成若干个子序列，此时子序列中的元素数相对较少，在各子序列内进行直接插入排序，当整个序列基本有序后，再对整个序列进行直接插入排序。^[1]

那么，如何对数组元素进行分组呢？
希尔算法利用增量(increment)实现跳跃分隔，将数组中相距某个增量的元素分为一组，比如0-3-6、1-4-7、2-5-8。

希尔排序是将待排序的数组元素，按下标的一定增量分组，分成多个子序列，然后对各个子序列进行直接插入排序算法排序；然后依次缩减增量再进行排序，直到增量为1时，进行最后一次直接插入排序，排序结束。^[2]

增量（inc）取值时，需注意以下几点：

1. 1 <= inc <= n(n为数组大小)；
2. 初始化时，一般可令inc = n // 2；
3. 每次迭代后，令inc = inc // 2 + 1；
4. 最后一个增量必须为1.

以下面的数组为例，对其使用希尔排序算法进行升序排序：
901050803070406020

1. inc初始值等于len(li)，即inc等于9；
2. 进入循环，inc = 9 // 3 + 1 = 4：
3. 第一次迭代，inc = 4：
   • i = 4：li[4] < li[0](40 < 90)，令t = li[[4] = 30，j = 0，进入第二个while循环，当j >= 0且t < li[j]（li[4] < li[0])时，令li[4] = li[0] = 90，j = j - inc = -4，因为j < 0，退出第二个while循环；
   • li[j+inc] = li[-4+4] = li[0] = t = 30，此时，数组li变为：
     301050809070406020
   • i = 5：li[5] > li[1](70 > 10)，不进入后续程序块；
   • i = 6：li[6] < li[2](40 < 50)，令t = li[6] = 40，j = i - inc = 2，进入第二个while循环，当j >= 0且t < li[j]（li[6] < li[2])时，令li[6] = li[2] = 50，j = j - inc = -2，因为j < 0，退出第二个while循环；
   • li[j+inc] = li[-2+4] = li[2] = t = 50，此时，数组li变为：
     301040809070506020
   • i = 7：li[7] < li[3](60 < 80)，令t = li[7] = 60，j = i - inc = 3，进入第二个while循环，当j >= 0且t < li[j]（li[7] < li[3])时，令li[7] = li[3] = 80，j = j - inc = -1，因为j < 0，退出第二个while循环；
   • li[j+inc] = li[-1+4] = li[3] = t = 60，此时，数组li变为：
     301040609070508020
   • i = 8：li[8] < li[4](20 < 90)，令t = li[8] = 20，j = i - inc = 4，进入第二个while循环，当j >= 0且t < li[j]（li[8] < li[4])时，令li[8] = li[4] = 90，j = j - inc = 0，因为j = 0且t < li[0](20 < 30)，所以li[4] = li[0] = 30，j = j - inc = -4；
   • 因为j < 0，退出第二个while循环，li[j+inc] = li[-4+4] = li[0] = t = 20，此时，数组li变为：
     201040603070508090
4. 第二次迭代，inc = inc // 3 + 1 = 2：
   • i = 2：li[2] > li[0](40 > 20)，不进入后续程序块；
   • i = 3：li[3] > li[1](60 > 10)，不进入后续程序块；
   • i = 4：li[4] < li[2](30 < 40)，令t = li[4] = 30，j = i - inc = 2，进入第二个while循环，当j >= 0且t < li[j]（li[4] < li[2])时，令li[4] = li[2] = 40，j = j - inc = 0，因为j = 0但t > li[0](30 > 20)，退出第二个while循环；
   • li[j+inc] = li[0+2] = li[2] = t = 30，此时，数组li变为：
     201030604070508090
   • i = 5：li[5] > li[3]（70 > 60)，不进入后续程序块；
   • i = 6：li[6] > li[4](50 > 40)，不进入后续程序块；
   • i = 7：li[7] > li[5](80 > 70)，不进入后续程序块；
   • i = 8：li[8] > li[6](90 > 50)，不进入后续程序块；
5. 第三次迭代，inc = inc // 3 + 1 = 1：
   • i = 1：li[1] < li[0](10 < 20)，令t = li[1] = 10，j = i - inc = 0，进入第二个while循环，当j >= 0且t < li[j]（li[1] < li[0])时，令li[1] = li[0] = 20，j = j - inc = -1，因为j < 0，退出第二个while循环；
   • 此时，数组li变为：
     102030604070508090
   • i = 2：li[2] > li[1](30 > 20)，不进入后续程序块；
   • i = 3：li[3] > li[2](60 > 30)，不进入后续程序块；
   • i = 4：li[4] < li[3](40 < 60)，令t = li[4] = 40，j = i - inc = 3，进入第二个while循环，当j >= 0且t < li[j]（li[4] < li[3])时，令li[4] = li[3] = 60，j = j - inc = 2，因为j > 0但t > li[2](40 > 30)，退出第二个while循环；
   • li[j+inc] = li[2+1] = li[3] = t = 40，此时，数组li变为：
     102030406070508090
   • i = 5：li[5] > li[4](70 > 60)，不进入后续程序块；
   • i = 6：li[6] < li[5](50 < 70)，令t = li[5] = 50，j = i - inc = 5，进入第二个while循环，当j >= 0且t < li[j]（li[6] < li[5])时，令li[6] = li[5] = 70，j = j - inc = 4，因为j > 0且t < li[4](50 < 60)，li[5] = li[4] = 60，j = j - inc = 3，因为j > 0但t > li[3](50 > 40)，退出第二个while循环；
   • li[j+inc] = li[3+1] = li[4] = t = 50，此时，数组li变为：
     102030405060708090
   • i = 7：li[7] > li[6](80 > 70)，不进入后续程序块；
   • i = 8：li[8] > li[7](90 > 80)，不进入后续程序块；

三、代码实现

def shellSort(li):
    """
    希尔排序，属于插入排序类，不稳定排序，通过利用增量实现跳跃式的移动，从而提高效率
    时间复杂度O(n1.5)
    """
    inc = len(li)
    # 利用while True和break语句，实现do ... while ...效果，即循环内代码至少执行一次
    while True:
        inc = inc // 3 + 1  # 增量
        for i in range(inc, len(li)):
            if li[i] < li[i-inc]:
                t = li[i]
                j = i - inc
                while j >= 0 and t < li[j]:
                    li[j+inc] = li[j]
                    j -= inc
                li[j+inc] = t  # 插入
                # print('inc=%s i=%s j=%s' % (inc, i, j), li)  # 输出中间过程结果
        # 增量为1时停止循环
        if inc <= 1:
            break
    return li

if __name__ == '__main__':
    li = [90, 10, 50, 80, 30, 70, 40, 60, 20]
    print('希尔排序：', shellSort(li.copy()))

以上，欢迎指正交流~

---

参考资料：
[1] 《大话数据结构》
[2] 排序：希尔排序（算法）

---

排序算法系列——相关文章：

[1] 排序算法(一)——冒泡排序算法详解及Python实现
[2] 排序算法(二)——简单选择排序算法详解及Python实现
[3] 排序算法(三)——直接插入排序算法详解及Python实现
[4] 排序算法(四)——希尔排序算法详解及Python实现
[5] 排序算法(五)——堆排序算法详解及Python实现
[6] 排序算法(六)——归并排序算法详解及Python实现
[7] 排序算法(七)——快速排序算法详解及Python实现