排序算法-希尔排序

• • • 1、简单插入排序存在的问题
    • 2、希尔排序算法介绍
    • 3、希尔排序的基本思想
    • 4、图示分析希尔排序
    • 5、代码实现（交换式）
    • 6、代码实现（移位式）
    • 7、时间复杂度
    • 8、稳定性

我们看简单的插入排序可能存在的问题。

数组 arr = {2,3,4,5,6,1} 这是需要插入的数 1（最小），这样的过程是：

{2,3,4,5,1,6}
{2,3,4,1,5,6}
{2,3,1,4,5,6}
{2,1,3,4,5,6}
{1,2,3,4,5,6}

结论：当需要插入放入数是较小的数时，后移的次数明显增多，对效率有影响

希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为最小增量排序

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

• 将数的个数设为n，取奇数k=n/2，将下标差值为k的书数为一组，构成有序序列。

• 再取k=k/2 ，将下标差值为k的数分为一组，构成有序序列。

• 重复第二步，直到k=1执行简单插入排序。

增量d 的范围：1<= d < 待排序数组的长度 （d 需为 int 值）
增量的取值：一般的初次取序列（数组）的一半为增量，以后每次减半，直到增量为1。

第一个增量 = 数组的长度/2,

第二个增量 = 第一个增量/2,

第三个增量 = 第二个增量/2,

以此类推，最后一个增量=1。

如何写成代码：

• 首先确定分的组数。
• 然后对组中元素进行插入排序。
• 然后将length/2，重复1,2步，直到length=0为止。

    public static void shellSort(int [] arr){

        //组数
        int a = arr.length / 2;
        int temp = 0; //用于交换的变量
        do {
            for (int i = a; i < arr.length; i++) {
                for (int j = i - a ; j >= 0 ; j -= a) {
                    if (arr[j] > arr[j+a]){
                        temp = arr[j];
                        arr[j] = arr[j+a];
                        arr[j+a] = temp;
                    }
                }
            }
            System.out.println(Arrays.toString(arr));
            a /= 2;
        }while (a > 0);
     }

    public static void shellSort2(int [] arr){

        for (int gap = arr.length / 2; gap > 0; gap/=2) {
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]){
                    while ((j - gap) >= 0 && temp < arr[j-gap]){
                        arr[j] = arr[j-gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
        }
    }

1. 最好情况：序列是正序排列，在这种情况下，需要进行的比较操作需（n-1）次。后移赋值操作为0次。即O(n)

2. 最坏情况：O(nlog2n)。

由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。