排序算法4-希尔排序

描述

希尔排序是对插入排序的优化版本，它解决了当较小值出现在序列尾部，需要频繁向前比对的过程

流程

1、算法对序列进行分组，选取一个gap值作为分组的组数、以及步长（例如gap=5，即分为5组；每组元素相隔步长5，下标0和5一组、下标1和6一组，以此类推）
2、对每组进行插入排序（其中插入排序可分为交换法和移位法，移位法效率高）
3、对gap值进行模2运算，即gap / 2，并重新进行1、2步骤
4、直到gap = 1，即是整个序列为一个分组，并对其进行插入排序后，算法结束

代码实现

/**
 * 希尔排序
 */
public class ShellSort {
    public static void main(String[] args) {

        int[] arr = {2, 6, 8, 1, 7, 3, 4, 0, -8, -3};
        shellSort1(arr);

    }

    /**
     * 交换法
     *
     * @param arr
     */
    public static void shellSort1(int[] arr) {
        //放交换值的工具人
        int temp;
        //排序次数
        int count = 0;

        //增量gap，并逐步缩小增量（是分组情况，也是每组步长）
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //循环每组
            for (int i = gap; i < arr.length; i++) {
                //组内进行循环交换排序
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
            System.out.println("第" + (++count) + "次排序: " + Arrays.toString(arr));
        }
    }

    /**
     * 移位法
     *
     * @param arr
     */
    public static void shellSort2(int[] arr) {
        int temp;
        int j;
        int count = 0;

        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //循环每组，组内进行插入排序
            for (int i = gap; i < arr.length; i++) {
                j = i;
                temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && arr[j - gap] > temp) {
                        //在有序组里，向前移动，向前移动的跨度也应该调整为gap
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    //退出while循环，找到自己的位置
                    arr[j] = temp;
                }
            }
            System.out.println("第" + (++count) + "次排序: " + Arrays.toString(arr));
        }
    }
}

性能

最好的情况复杂度为O(n)；最差的情况是O(N^2)；但平均复杂度要比直接插入小；不稳定算法