java数据结构和算法——插入排序算法

一、插入排序算法的基本介绍

• 插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

二、插入排序算法的思想

• 把n个待排序的元素看成为一个有序表和一个无序表
• 开始时有序表中只包含一个元素，无序表中包含有n-1个元素
• 排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

三、插入排序算法的思路分析图

四、插入排序算法的应用示例需求

示例需求：有一群牛 , 颜值的打分分别是 101, 34, 119, 1 请使用插入排序从低到高进行排序

五、插入排序算法推导过程示例演示

1、代码

package com.rf.springboot01.dataStructure.sort;

import java.util.Arrays;

/**
 * @description: 插入排序算法推导过程示例演示
 * @author: xiaozhi
 * @create: 2020-08-07 08:51
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr={101, 34, 119, 1};
        System.out.println("排序前的数组=================");
        System.out.println(Arrays.toString(arr));

        insertSort(arr);

        System.out.println("排序后的数组=================");
        System.out.println(Arrays.toString(arr));
    }

    public static void insertSort(int[] arr){


        //第一轮排序的原数素组{101, 34, 119, 1}
        int insertValue=arr[1];//定义一个待插入的数,第一次比较把34赋值给insertValue
        int insertIndex= 1-1;//定义一个待插入的数前面的数的下标

        //给insertValue 找到插入的位置
        //1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
        //2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
        while(insertIndex>=0  && insertValue < arr[insertIndex]){
            //将 arr[insertIndex] 后移,
            //即第一次找位置是把arr[0]=101赋值给arr[1]的位置,示例中数组展示为101, 101, 119, 1
             arr[insertIndex+1]=arr[insertIndex];
             insertIndex--;
        }
        //当退出while循环时，说明插入的位置找到, insertIndex + 1
        arr[insertIndex + 1] = insertValue;
        System.out.println("第1轮插入排序后的数组-----------------");
        System.out.println(Arrays.toString(arr));


        //第二轮排序以第一轮排序的结果为基础{34, 101, 119, 1}
        insertValue=arr[2];//定义一个待插入的数,第一次比较把119赋值给insertValue
        insertIndex= 2-1;//定义一个待插入的数前面的数的下标

        //给insertValue 找到插入的位置
        //1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
        //2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
        while(insertIndex>=0  && insertValue < arr[insertIndex]){
            //将 arr[insertIndex] 后移,
            arr[insertIndex+1]=arr[insertIndex];
            insertIndex--;
        }
        //当退出while循环时，说明插入的位置找到, insertIndex + 1
        arr[insertIndex + 1] = insertValue;
        System.out.println("第2轮插入排序后的数组-----------------");
        System.out.println(Arrays.toString(arr));


        //第三轮排序以第二轮排序的结果为基础{34, 101, 119, 1}
        insertValue=arr[3];//定义一个待插入的数,第一次比较把1赋值给insertValue
        insertIndex= 3-1;//定义一个待插入的数前面的数的下标

        //给insertValue 找到插入的位置
        //1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
        //2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
        while(insertIndex>=0  && insertValue < arr[insertIndex]){
            //将 arr[insertIndex] 后移,
            //第一次找位置是把arr[2]=119赋值给arr[3]的位置,示例中数组展示为34, 101, 119, 119
            //第二次找位置是把arr[1]=101赋值给arr[2]的位置,示例中数组展示为34, 101, 101, 119
            //第三次找位置是把arr[0]=34赋值给arr[1]的位置,示例中数组展示为34, 34, 101, 119
            arr[insertIndex+1]=arr[insertIndex];
            insertIndex--;
        }
        //当退出while循环时，说明插入的位置找到, insertIndex + 1
        arr[insertIndex + 1] = insertValue;
        System.out.println("第3轮插入排序后的数组-----------------");
        System.out.println(Arrays.toString(arr));
    }
}

2、运行main函数，运行结果如下：

六、插入排序算法的完整示例演示

1、代码

package com.rf.springboot01.dataStructure.sort;

import java.util.Arrays;

/**
 * @description: 插入排序算法完整示例
 * @author: xiaozhi
 * @create: 2020-08-07 09:13
 */
public class InsertSort2 {
    public static void main(String[] args) {
        int[] arr={101, 34, 119, 1};
        System.out.println("排序前的数组=================");
        System.out.println(Arrays.toString(arr));

        insertSort(arr);

        System.out.println("排序后的数组=================");
        System.out.println(Arrays.toString(arr));
    }

    public static void insertSort(int[] arr){
        int insertValue=0;
        int insertIndex=0;
        for(int i=1;i<arr.length;i++){
            //第一轮排序的原数素组{101, 34, 119, 1}
            insertValue=arr[i];//定义一个待插入的数,第一次比较把34赋值给insertValue
            insertIndex= i-1;//定义一个待插入的数前面的数的下标

            //给insertValue 找到插入的位置
            //1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
            //2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
            while(insertIndex>=0  && insertValue < arr[insertIndex]){
                //将 arr[insertIndex] 后移,
                //即第一次找位置是把arr[0]=101赋值给arr[1]的位置,示例中数组展示为101, 101, 119, 1
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            //当退出while循环时，说明插入的位置找到, insertIndex + 1
            //这里我们判断是否需要赋值
            if(insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertValue;
            }
            System.out.println("第"+i+"轮插入排序后的数组-----------------");
            System.out.println(Arrays.toString(arr));
        }
    }


}

2、运行main函数，结果如下：

七、测试插入排序算法所消耗的时间示例

1、代码

package com.rf.springboot01.dataStructure.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

/**
 * @description: 插入排序耗时示例演示
 * @author: xiaozhi
 * @create: 2020-08-07 09:17
 */
public class InsertSort3 {

    public static void main(String[] args) {
        int arr[] = new int[100000];
        for(int i=0;i<100000;i++){//创建一个带有100000个随机数的数组
            arr[i]= (int) (Math.random()*8000000); //随机生成（0到8000000之间）的数
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间是=" + date1Str);

        insertSort(arr);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序前的时间是=" + date2Str);

    }

    public static void insertSort(int[] arr){
        int insertValue=0;
        int insertIndex=0;
        for(int i=1;i<arr.length;i++){
            //第一轮排序的原数素组{101, 34, 119, 1}
            insertValue=arr[i];//定义一个待插入的数,第一次比较把34赋值给insertValue
            insertIndex= i-1;//定义一个待插入的数前面的数的下标

            //给insertValue 找到插入的位置
            //1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
            //2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
            while(insertIndex>=0  && insertValue < arr[insertIndex]){
                //将 arr[insertIndex] 后移,
                //即第一次找位置是把arr[0]=101赋值给arr[1]的位置,示例中数组展示为101, 101, 119, 1
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            //当退出while循环时，说明插入的位置找到, insertIndex + 1
            //这里我们判断是否需要赋值
            if(insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertValue;
            }
        }
    }
}

2、运行main函数，运行结果如下：

本地计算机，win10系统，8G内存测试带有100000个随机数的数组，用插入排序算法耗时大约1秒