常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：

关于时间复杂度：

1.     平方阶 (O(n2)) 排序各类简单排序：直接插入、直接选择和冒泡排序。

2.     线性对数阶 (O(nlog2n)) 排序快速排序、堆排序和归并排序；

3.     O(n1+§))排序，§ 是介于 0 和 1 之间的常数。希尔排序

4.     线性阶 (O(n)) 排序基数排序，此外还有桶、箱排序。

关于稳定性：

     稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

     不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释：

     n：数据规模

     k：“桶”的个数

     In-place：占用常数内存，不占用额外内存

     Out-place：占用额外内存

     稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

希尔排序

希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

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

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；

• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

1. 算法步骤

1.       选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

2.       按增量序列个数 k，对序列进行 k 趟排序；

3.       每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

2. JavaScript 代码实现

functionshellSort(arr) {
    var len =arr.length,
        temp,
        gap =1;
    while(gap < len/3) {          //动态定义间隔序列
        gap =gap*3+1;
    }
    for (gap; gap >0; gap =Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >=0&& arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

3. 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
}

4. Go 代码实现

func shellSort(arr []int) []int {
            length := len(arr)
            gap := 1
            for gap < gap/3 {
                        gap = gap*3 + 1
            }
            for gap > 0 {
                        for i := gap; i < length; i++ {
                                     temp := arr[i]
                                     j := i - gap
                                     for j >= 0 && arr[j] > temp {
                                                 arr[j+gap] = arr[j]
                                                 j -= gap
                                     }
                                     arr[j+gap] = temp
                        }
                        gap = gap / 3
            }
            return arr
}

5.Java代码实现

public void shellSort(int[] list) {
    int gap = list.length / 2;
 
    while (1 <= gap) {
        // 把距离为 gap 的元素编为一个组，扫描所有组
        for (int i = gap; i < list.length; i++) {
            int j = 0;
            int temp = list[i];
 
            // 对距离为 gap 的元素组进行排序
            for (j = i - gap; j >= 0 && temp < list[j]; j = j - gap) {
                list[j + gap] = list[j];
            }
            list[j + gap] = temp;
        }
 
        System.out.format("gap = %d:\t", gap);
        printAll(list);
        gap = gap / 2; // 减小增量
    }
}

探讨交流技术、或者对编程感兴趣，都可以加我qq： 525331804 

本文出自 “知乎技术” 博客，请务必保留此出处http://liuzhiying.blog.51cto.com/5850988/1927295

算法系列【希尔排序】篇