插入排序算法汇总---附JAVA语言实现

在介绍算法之前，我先给大家介绍一个很好用的网站，里面的可视化过程可以帮助你更好的理解数据结构和算法
VISUALGO.NET: https://visualgo.net/zh.

可视化过程：

以下内容以算法的思想、特征、实现三方面进行讲解

一、直接插入排序

基本思想：每次将一个待排序的记录按其关键字大小插入到前面已排好的子序列。类似于打牌的时候，手中扑克牌的排序。

特征：

• 适用于顺序存储表和链式存储表；
• 应用于基本有序和数据量小的排序表；
• 因为只使用一个辅助空间，空间效率为O(1)；
• 在排序过程中，插入执行了n-1次，每次插入都有比较和移动操作。其中比较和移动操作取决于表的初始状态。
  • 最好情况下，表已经有序，只比较一次而不移动，因此时间效率为O(n)
  • 最坏情况下，表为逆序，比较次数为(n+2)(n-1)/2,移动次数为(n+4)(n-1)/2,时间效率为O(n^2)
  • 平均情况，因为表中元素是随机的，所以取最好最坏平均值，时间效率为O(n^2)
  • 每次插入元素都是从后向前比较，所以相同元素的相对位置不会改变。因此是稳定的排序方法

实现：(JAVA)

/**
 * 直接插入排序
 * 适用于顺序储存和链表储存
 */
public class InsertSortDirect {

    int data[] = new int[16];
    int size=16;

    public static void main(String[] args) {

        InsertSortDirect insertsort = new InsertSortDirect();
        insertsort.creatData();
        insertsort.insert();
    }

    public void creatData(){
        //随机生成16个数字，存入到数组中

        for (int i=0;i<size;i++){
            int random = (int)(Math.random()*100+1);
            data[i] = random;
        }
        System.out.print("待排序的序列：");
        for (int j=0;j<size;j++){
            System.out.print(data[j]+" ");
        }
    }

    public void insert(){
        int temp = 0;
        int j;

        for (int i=1;i<size;i++){
            if (data[i]<data[i-1]){
                temp = data[i];
                for (j = i-1;j>=0 && temp<data[j];j--){
                    data[j+1] = data[j];
                }
                data[j+1] = temp;
            }
        }

        //另加代码，为了输出排序后的序列
        System.out.print("排序后的序列：");
        for (int k=0;k<size;k++){
            System.out.print(data[k]+" ");
        }
    }

    InsertSortDirect(){}
}

二、折半插入排序

折半插入序列是对直接插入序列的一个改进算法。在直接插入排序算法中，排序的过程是一边比较一边移动。而折半插入算法将比较和移动操作相分离。这里有一个点理解了，也就理解了折半插入算法的巧妙了，下面我们来看：
这里有一个排序到一半的序列{1，2，3，5，8，10，36，25，20，80，40}
此时元素比较到了25和36，此时你会发现25之前的序列是一个从小到大的序列，在{1，2，3，5，8，10，36}这段序列中使用折半查找（二分法）来找到25插入的位置，然后直接将25插入进去。这个过程就是将比较和移动的操作分离了。

基本思想：先折半查找出元素的待插入位置；然后统一地移动待插入位置之后地元素。

特征：

• 只适用于顺序存储表
• 折半插入只减少了比较元素的个数，约为O(nlogn)，比较次数仅取决于元素个数n
• 移动次数没有改变
• 因此该算法的时间效率为O(n^2)
• 适用于数据量不大的排序表

实现：

/**
 * 折半插入排序
 * 折半：Split-half->ff
 * 只适用于顺序储存
 */
public class InsertSortFf {
    int data[] = new int[16];
    int size=16;

    public static void main(String[] args) {

        InsertSortFf ffinsertsort = new InsertSortFf();
        ffinsertsort.creatData();
        ffinsertsort.insert();
    }

    public void creatData(){
        //随机生成16个数字，存入到数组中

        for (int i=0;i<size;i++){
            int random = (int)(Math.random()*100+1);
            data[i] = random;
        }
        System.out.print("待排序的序列：");
        for (int j=0;j<size;j++){
            System.out.print(data[j]+" ");
        }
    }

    public void insert(){
        int temp;
        int j;

        for (int i=1;i<size;i++){
            if (data[i]<data[i-1]){
                temp = data[i];

                //折半改进，新加入一段代码
                int low = 0,high = i-1;
                int mid;
                while (low<=high){
                    mid = (low+high)/2;
                    if (data[mid]>temp){
                        high = mid - 1;
                    }else{
                        low = mid + 1;
                    }
                }

                for (j = i-1;j>=0 && j>=high+1;j--){
                    data[j+1] = data[j];      //统一后移
                }
                data[high+1] = temp;
            }
        }

        //另加代码，为了输出排序后的序列
        System.out.print("排序后的序列：");
        for (int k=0;k<size;k++){
            System.out.print(data[k]+" ");
        }
    }

    InsertSortFf(){}
}

三、希尔排序

希尔排序也是对直接插入排序的改良。直接插入排序适用于基本有序和数据量小的排序表，希尔排序针对这两点做出了改进。希尔排序运用了分而治之的思想，将排序表的元素按步长分组，在各组之间进行直接插入排序，经过一轮后，缩小步长再次重复，知道步长等于1为止。此时各表已经是基本有序的，然后再将整个排序表进行直接插入排序，从而提高效率。

基本思想：把相隔某个“增量”的记录组成一个子表，然后对各个子表分别进行直接插入排序，当整个表中的元素是基本有序的状态时，再对整个表进行一次直接插入排序。

特征“：

• 只适用于顺序存储表
• 空间效率同上：O(1)
• 希尔排序的时间复杂度依赖于增量序列函数，但还没有找到最好的增量函数，所以时间复杂度约为O(n ^ 1.5)，在最坏情况下，时间复杂度为O(n^2)
• 一般选择增量序列为n/2，每次缩小的时候均除以2

实现:

/**
 * 希尔排序
 * 按步长分组,再直接插入
 * 适用于顺序存储
 */
public class InsertSortShell {
    int data[] = new int[16];
    int size=16;

    public static void main(String[] args) {

        InsertSortShell shellinsertsort = new InsertSortShell();
        shellinsertsort.creatData();
        shellinsertsort.insert();
    }

    public void creatData(){
        //随机生成16个数字，存入到数组中

        for (int i=0;i<size;i++){
            int random = (int)(Math.random()*100+1);
            data[i] = random;
        }
        System.out.print("待排序的序列：");
        for (int j=0;j<size;j++){
            System.out.print(data[j]+" ");
        }
        System.out.println("\n");
    }

    public void insert(){
        int temp;
        int i,j,dk;
        int k=1;  //目的是输出每一次循环的排序结果

        for (dk=size/2;dk>=1;dk=dk/2){
            for (i=dk+1;i<size;i++){
                if (data[i]<data[i-dk]){
                    temp = data[i];
                    for (j=i-dk;j>=0 && temp<data[j];j-=dk){
                        data[j+dk] = data[j];
                    }
                    data[j+dk] = temp;
                }
            }

            //每循环一次就输出一次
            System.out.print("第"+ (k++) +"次排序：");
            for (int l=0;l<size;l++){
                System.out.print(data[l]+" ");
            }
            System.out.println();
        }
    }

    public InsertSortShell() {}
}

希尔排序不容易直观理解，读者最好思考希尔算法改进了什么问题，根据希尔算法的思想和特性并自己手动敲代码去进行深入理解。

参考书目：

• 大话数据结构
• 王道数据结构考研指导
• 图解数据结构—使用JAVA
• 算法(第4版)

如有错误，欢迎指正