[数据结构和算法]希尔排序

1. 概述

希尔排序也成为“缩小增量排序”，其基本原理是，现将待排序的数组元素分成多个子序列，使得每个子序列的元素个数相对较少，然后对各个子序列分别进行直接插入排序，待整个待排序列“基本有序”后，最后在对所有元素进行一次直接插入排序。因此，我们要采用跳跃分割的策略：将相距某个“增量”的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序。希尔排序是对直接插入排序算法的优化和升级。

所谓的基本有序，就是小的关键字基本在前面，大的基本在后面，不大不小的基本在中间，例如｛2,1,3,6,4,7,5,8,9,｝就可以称为基本有序了。但像｛1,5,9,3,7,8,2,4,6｝这样，9在第三位，2在倒数第三位就谈不上基本有序。

2. 时间复杂度

希尔排序的关键并不是随便分组后各自排序，而是将相隔某个“增量”的记录组成一个子序列，实现跳跃式移动，使得排序的效率提高。需要注意的是，增量序列的最后一个增量值必须等于1才行。另外，由于记录是跳跃式的移动，希尔排序并不是一种稳定的排序算法。
希尔排序最好时间复杂度和平均时间复杂度（nlogn），最坏时间复杂度为。

3. 图解

以数组{26, 53, 67, 48, 57, 13, 48, 32, 60, 50 }为例，步长序列为{5,2,1}
初始化关键字： [26, 53, 67, 48, 57, 13, 48, 32, 60, 50 ]

4. Java源码

public class ShellSort {

    public static void sort(Comparable[] a) {
        int N = a.length;
        int h = 1;
        while(h < N/3) h = 3*h + 1;
        for(h = h; h > 0; h = h/3) {
            for(int i = h; i < N; i++) {
                for(int j = i - h; j >= 0; j -= h) {
                    if(less(a[j], a[j + h])) exch(a, j, j + h);

                } 

            }
        }



    }

    public static boolean less(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) < 0;
    }

    public static void exch(Comparable[] c, int i, int j) {
        Comparable tmp = c[i];
        c[i] = c[j];
        c[j] = tmp;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer[] a = {26, 53, 67, 48, 57, 13, 48, 32, 60, 50};
        System.out.println("未排序数据：");
        for(Integer t : a)
            System.out.print(t + "    ");
        sort(a);
        System.out.println("已排序数据：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "   ");
        }



    }
}

//结果
未排序数据：
26    53    67    48    57    13    48    32    60    50    
4有序数组：60   53   67   48   57   50   48   32   26   13   
1有序数组：67   60   57   53   50   48   48   32   26   13   
已排序数据：
67   60   57   53   50   48   48   32   26   13