排序算法 - 希尔排序过程【移位】【交换】与速度测试

插入排序的缺陷

插入排序是定义有序表、无序表，将无序表元素一个个插入有序表

但当存在小数据位于无序表末尾1,2,3,4,5,6,7,0，插入排序时，最后一轮需要赋值8次，十分影响效率

有没有办法解决呢？对于插入排序的优化，提出了希尔排序

希尔排序

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。

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

希尔排序是插入排序的优化版：它先对数组根据原始增量分组，将所有的分组插入排序，然后减小增量，继续上一步（分组=》排序），直到增量为1，整个文件是一组，再进行插入排序，数组就有序了

希尔排序明明进行了多次插入排序，怎么会优于一次完全的插入排序呢？

希尔排序是基于插入排序的以下性质而提出改进方法的：

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。
• 在元素数量较少的情况下，插入排序的效率高
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

希尔排序先对数据进行预处理，分组后每组数据量都较少，插入排序快

当最后一次完整的插入排序时，数组已经基本有序了，再进行插入排序就可以很快的完成

Java实现希尔排序过程（交换法）

上面的数组8,9,1,7,2,3,5,4,6,0，会进行3轮排序，把三轮排序过程显示

package com.company.sort;

import java.util.Arrays;

/**
 * @author zfk
 * 希尔排序算法
 */
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
        shellSort(arr);
    }

    public static void shellSort(int[] arr){
        int temp = 0;

        //希尔排序的第一轮
        //第一轮排序是将十个数据分成了5组
        for (int i = 5;i < arr.length;i++){
            //遍历各组中所有的元素，每组有2个元素，步长5
            //第i个 和 第i+5个 是一组
            for (int j = i - 5;j >= 0;j -= 5){
                //如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j] > arr[j+5]){
                    temp = arr[j];
                    arr[j] = arr[j+5];
                    arr[j+5] = temp;
                }
            }
        }
        System.out.println("希尔排序第一轮后："+ Arrays.toString(arr));


        //希尔排序的第二轮
        //第二轮排序是将十个数据分成了5/2 = 2组
        for (int i = 2;i < arr.length;i++){
            //遍历各组中所有的元素，每组有5个元素，步长2
            //1-3-5-7-9 是一组
            for (int j = i - 2;j >= 0;j -= 2){
                //如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j] > arr[j + 2]){
                    temp = arr[j];
                    arr[j] = arr[j + 2];
                    arr[j + 2] = temp;
                }
            }
        }
        System.out.println("希尔排序第二轮后："+ Arrays.toString(arr));


        //希尔排序的第三轮
        //第三轮排序是将十个数据分成了 2/2 = 1组
        for (int i = 1;i < arr.length;i++){
            //经过第二轮排序后，数组基本有序[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
            //遍历数组中所有的元素
            for (int j = i - 1;j >= 0;j -= 1){
                //如果当前元素大于加上步长后的那个元素，说明交换
                if (arr[j] > arr[j + 1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("希尔排序第三轮后："+ Arrays.toString(arr));
    }
}

这是三轮排序的过程，当然，可以用一个for循环来表示多少轮

package com.company.sort;

import java.util.Arrays;

/**
 * @author zfk
 * 希尔排序算法
 */
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
        shellSort(arr);
    }

    public static void shellSort(int[] arr){

        int temp = 0;
        int count = 0;
        for (int gap = arr.length / 2;gap > 0;gap /= 2) {

            for (int i = gap; i < arr.length; i++) {
                //排序是将十个数据分成了gap组，每一组10/gap个元素，步长gap
                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));


        }
    }
}

交换法较容易理解，但效率并不会比插入排序高很多。。。

交换法还是会进行较多次的交换

移位法

交换法是每一个无序表元素与有序表比较，都会交换相邻两元素位置
如果能仅仅遍历，赋值后移动指针，找到插入位置后，再把元素插入到有序表，而不是多次交换加入有序表

 public static void shellSort2(int[] arr) {
        //增量gap
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //从第gap个元素，逐个对其所在的组进行插入排序
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];

                //当后一个数小于前一个相对应的数 或者 到了数组边界
                while (j - gap >= 0 && temp < arr[j - gap]) {
                    //将前一个数赋值给后一个数
                    arr[j] = arr[j - gap];

                    j -= gap;
                }
                //当退出循环，给temp找到了插入的位置
                arr[j] = temp;

            }
        }
    }

测试速度

随机生成8000个0~80000内的数据，进行排序

public static void main(String[] args) {
        int[] arr = new int[8000];
        for(int i = 0 ;i <arr.length;i++){
            //随机生成80000内的整数
            arr[i] = (int) (Math.random()*80000);
        }
        Date dataBefore = new Date();

        shellSort(arr);

        Date dateAfter = new Date();

        System.out.println("交换法消耗了："+(dateAfter.getTime()-dataBefore.getTime())+"ms");

        int[] arr2 = new int[8000];
        for(int i = 0 ;i <arr2.length;i++){
            //随机生成80000内的整数
            arr2[i] = (int) (Math.random()*80000);
        }
        Date dataBefore2 = new Date();
        shellSort2(arr2);
        Date dateAfter2 = new Date();

        System.out.println("移位法消耗了："+(dateAfter2.getTime()-dataBefore2.getTime())+"ms");

    }

移位法比交换法快了很多，很明显arr[j] = arr[j - gap]赋值优于temp = arr[j];arr[j] = arr[j + gap]; arr[j + gap] = temp;交换值