数据结构小白之插入排序算法

1.插入排序

1.1 思路

将n个需要排序的元素看成两个部分，一个是有序部分，一个是无序部分，开始的时候有序表只有一个元素,无序表有n-1个元素

排序过程中每次从无序表中取出元素，然后插入到有序表的适当位置，从而成为新的有序表

(类似排队，如果先叫几位同学按照学号排队站好，然后让其他同学按照那几位同学的位置为准，继续排队，这样的话比杂乱无章要快得多)

1.2 举个栗子

假设需要将一个数组arr {101,34,119,1}进行排序

1.2.1:

第一轮以101为准 然后将34插入其中，

由于34<101 所以第一轮过后，有序部分34 101 无序部分为119,1

 public static void insertFirstSort(int[] arr) {
        //第一轮
        /**
         * {101,34,119,1}->{34,101,119,1}
         * */

        //定义待插入的数
        int insertVal = arr[1];
        int insertIndex = 1 - 1;//需要比较的索引 arr[1]的前面这个数的下标
        //保证不越界
        //34<101?
        //将arr[insertIndex]后移
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex]; //{101,101,119,1}
            //arr[insertIndex]=insertVal;// {34,101,119,1}
            insertIndex--;
        }
        arr[insertIndex + 1] = insertVal;
        System.out.println(Arrays.toString(arr));
    }

1.2.2

第二轮将119插入34 101之间

第二轮过后，有序部分为34 101 119 无序部分为1

 public static void insertSecondSort(int[] arr) {
        //第二轮
        /**
         * {101,34,119,1}->{34,101,119,1}
         * */

        //定义待插入的数
        int insertVal = arr[2];
        int insertIndex = 2 - 1;//需要比较的索引 arr[1]的前面这个数的下标
        //保证不越界
        //34<101?
        //将arr[insertIndex]后移
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex]; //{101,101,119,1}
            //arr[insertIndex]=insertVal;// {34,101,119,1}
            insertIndex--;
        }
        arr[insertIndex + 1] = insertVal;
        System.out.println(Arrays.toString(arr));
    }

1.2.3

第三轮将1插入 34 101 119之间

第三轮过后，有序部分为1 34 101 119 算法结束 ，执行arr.length-1次

 public static void insertThirdSort(int[] arr) {
        //第二轮
        /**
         * {101,34,119,1}->{34,101,119,1}
         * */

        //定义待插入的数
        int insertVal = arr[3];
        int insertIndex = 3 - 1;//需要比较的索引 arr[1]的前面这个数的下标
        //保证不越界
        //34<101?
        //将arr[insertIndex]后移
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex]; //{101,101,119,1}
            //arr[insertIndex]=insertVal;// {34,101,119,1}
            insertIndex--;
        }
        arr[insertIndex + 1] = insertVal;
        System.out.println(Arrays.toString(arr));
    }

1.2.4 因此可以使用一个外循环来概括所有的重复性操作

public static void insertFinalSort(int[] arr) {
        for (int i = 1; i <arr.length ; i++) {
            //定义待插入的数
            int insertVal = arr[i];
            int insertIndex = i - 1;//需要比较的索引 arr[1]的前面这个数的下标
            //保证不越界
            //34<101?
            //将arr[insertIndex]后移
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex]; //{101,101,119,1}
               // arr[insertIndex]=insertVal;// {34,101,119,1}
                insertIndex--;
            }
            //判断是否需要赋值
            if(insertIndex+1!=i){
                //没有必要执行
                arr[insertIndex + 1] = insertVal;
            }

        }
        System.out.println(Arrays.toString(arr));
    }

1.2.5 调一波main

public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        System.out.println("原始数据:"+Arrays.toString(arr));
        System.out.println("第一轮排序:");
        insertFirstSort(arr);
        System.out.println("第二轮排序:");
        insertSecondSort(arr);
        System.out.println("第三轮排序:");
        insertThirdSort(arr);
        System.out.println("-------------------");
        insertFinalSort(arr);

    }