学习笔记-排序算法(插入排序)

介绍

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

插入排序法思想

插入排序(Insertion Sorting)的基本思想是:把n个待排序的元素看成为一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表.

插入排序思路图

实现逻辑

以数组int[] arr = {101,34,119,1}为例.
第一次给34找位置

		//定义待插入的数
        int insertVal = arr[1];//34
        int insertIndex = 1 -1;//即arr[1]前面这个数的下标   0
        //insertIndex >= 0 保证下标不会越界
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) { //34 如果小于 101
            arr[insertIndex + 1] = arr[insertIndex];//将下标1位置改为下标为0的值(101),arr = {101,101,119,1}
            insertIndex--;//0--不会进入下次循环
        }
        //可以优化,判断是否需要赋值
        //insertIndex在上面已经为0-- = -1,所以-1加1等于0
       arr[insertIndex + 1] = insertVal;//将之前保存的34存入到下标为0的位置
       System.out.println("第1轮插入");
       System.out.println(Arrays.toString(arr));//最终结果[34, 101, 119, 1]

第二次给119找位置

		//定义待插入的数
        int insertVal = arr[2];//119
        int insertIndex = 2 -1;//即arr[2]前面这个数的下标   1
        //insertIndex >= 0 保证下标不会越界
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) { //119大于 101,所以不会进入循环
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
       //没有进入到循环,所以insertIndex= 1;
       arr[insertIndex + 1] = insertVal;//将之前保存的119存入到下标为2的位置
       System.out.println("第2轮插入");
       System.out.println(Arrays.toString(arr));//最终结果[34, 101, 119, 1]

第三次给1找位置

		//定义待插入的数
        int insertVal = arr[3];//1
        int insertIndex = 3 -1;//即arr[3]前面这个数的下标   2
        //insertIndex >= 0 保证下标不会越界
        //备注:
        //第一次进入判断时(1<119),条件满足,所以将arr[2+1] = arr[2],最终结果[34, 101, 119, 119] insertIndex-- = 为1
        //第二次进入判断时(1<101),条件满足,所以将arr[1+1] = arr[1],最终结果[34, 101, 101, 119] insertIndex-- = 为0
        //第三次进入判断时(1<34),条件满足,所以将arr[0+1] = arr[0],最终结果[34, 34, 101, 119] insertIndex-- = 为-1
        //第四次进入判断,(-1<0)条件不满足
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
       //将之前保存的1保存到arr[-1+1] = 1;
       arr[insertIndex + 1] = insertVal;//arr[0] = 1 结果[1, 31, 101, 119]
       System.out.println("第3轮插入");
       System.out.println(Arrays.toString(arr));//最终结果[1, 31, 101, 119]

最终代码

public class InsertSort {

    public static void main(String[] args) {
        //测试一下插入的的速度,80000个数据所花费的时间
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 80000);//生成[0,80000)数
        }
        Date data1 = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = format.format(data1);
        System.out.println("排序前的时间是" + format1);
        
        insertSort(arr);

        Date data2 = new Date();
        String format2 = format.format(data2);
        System.out.println("排序后的时间是" + format2);
    }

    //插入排序
    public static void insertSort(int[] arr) {
        int insertVal = 0;
        int insertIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            //定义待插入的数
            insertVal = arr[i];
            insertIndex = i -1;//即arr[i]前面这个数的下标
            //insertIndex >= 0 保证下标不会越界
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) { //34 如果小于 101
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            //优化,判断是否需要赋值
            if (insertIndex +1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
    }
}

存在的问题

我们看简单的插入排序可能存在的问题.
数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是：
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响.

解决方案

使用希尔排序