排序(四)：希尔排序法

一. 基本思想
    1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

• 算法描述
  先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
  选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  按增量序列个数k，对序列进行k 趟排序；
  每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
  
  首先它把较大的数据集合分割成若干个小组（逻辑上分组），然后对每一个小组分别进行插入排序，此时，插入排序所作用的数据量比较小（每一个小组），插入的效率比较高。

二. 代码实现

• 版本一

/**
 - <br>希尔排序</br>
 - 缩小增量排序
 */
public class ShellSort {

    public static void sort(int[] a) {
        int d = a.length / 2 ;
        while (d >=1) {
            for (int x = 0; x < d; x++) {
                for (int i = x + d; i < a.length; i = i + d) {
                    int temp = a[i];
                    int j;
                    for (j = i - d; j >= 0 && a[j] > temp; j = j - d) {
                        a[j + d] = a[j];
                    }
                    a[j + d] = temp;
                }
            }
            d = d / 2;
        }
    }
}

• 版本二

public class ShellSort2 {

    public static void sort(int[] arr) {
        int n = arr.length;
        // 计算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...
        int h = 1;
        while (h < n/3) {
            h = 3 * h + 1;
        }

        while (h >= 1) {
            for (int i = h; i < n; i++) {
                // 对 arr[i], arr[i-h], arr[i-2*h], arr[i-3*h]... 使用插入排序
                int temp = arr[i];
                int j = i;
                for ( ; j >= h && arr[j-h] > temp; j -= h) {
                    arr[j] = arr[j-h];
                }
                arr[j] = temp;
            }
            h /= 3;
        }
    }
}

三. 算法分析
对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
希尔排序的出现就是为了改进插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于 1。
希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。

• 时间复杂度
  希尔排序的复杂度和增量序列是相关的。
  {1,2,4,8,…}这种序列并不是很好的增量序列，使用这个增量序列的时间复杂度（最坏情形）是O(n^2)
  Hibbard提出了另一个增量序列{1,3,7，…,2^{k-1}，这种序列的时间复杂度(最坏情形)为O(n}1.5)
  Sedgewick提出了几种增量序列，其最坏情形运行时间为O（n^1.3）,其中最好的一个序列是{1,5,19,41,109,…}

• 稳定性
  不是稳定的，虽然插入排序是稳定的，但希尔排序是跳跃性插入的，有可能破坏稳定性。