常见排序算法（五）-希尔排序

希尔排序（Shell Sort）

　　希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。

　　希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n²）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

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

算法描述

　　我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。

　　希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

　　先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

• 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列个数k，对序列进行k 趟排序；
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

过程演示

 

代码实现

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] array = {4,6,2,14,12,36,5,95,41,75,11,21,14};
        for (int i : shellSort(array)) {
            System.out.print(i + " ");
        }

        System.out.println();

        String[] strings = {"b","a","a","d","z","e","f","G","X","y","Z"};
        Arrays.asList(shellSort(strings)).stream().forEach(s ->{
            System.out.print(s + " ");
        });
    }
    public static int[] shellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
    }

    public static String[] shellSort(String[] arr){
        int  increment = arr.length;
        while(increment > 1) {    //动态定义间隔序列
            increment =increment/3+1;
            for (int i = increment; i < arr.length; i++) {
                String temp = arr[i];
                int j = i-increment;
                while ( j >= 0 && arr[j].compareTo(temp) >0 ) {
                    arr[j+increment] = arr[j];
                    j-=increment;
                }
                arr[j+increment] = temp;
            }
        }
        return arr;
    }
}

算法分析

最佳情况：T(n) = O(nlog₂ n)  最坏情况：T(n) = O(nlog₂ n)  平均情况：T(n) =O(nlog₂n)