数据结构与算法之插入排序

数据结构与算法之冒泡排序
数据结构与算法之选择排序

一、核心思想

插入排序（Insertion Sorting）的基本思想是：把N个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次都从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置。

二、案例

原始数组：{100, 34, 80, 1}

需要对原始数组进行插入排序，每一轮都会确定一个最小数，且放到了最前面，所以轮数是n-1次。

第一轮插入排序：{34, 100, 80, 1}

核心思想：

1.可以想象为100这个数字（下标为0的）已经在左侧的有序表里了，所以需要从下标为1的数字开始拿

2.先从第二个数（下标为1的，这里是34）开始，让他和左边的数（也就是100）对比

3.值34小于100，所以将34放入到100的前面，所以第一轮是{34, 100, 80, 1}

第二轮插入排序：{34, 80, 100, 1}

核心思想：

1.再从第三个数（80）开始，让他和左边的数逐个对比

2.值80小于100，这时候不能直接放到左边后就不管了， 因为100左边还有数字，所以让80接着和100左边的数字34比较

3.值80大于34，所以不处理，所以最终位置是在100前面。也就是{34, 80, 100, 1}

第三轮插入排序：{1, 34, 80, 100}

核心思想：

1.从第四个数字（1）开始，让他和左边的数逐个对比

2.值1小于100， 因为100左边还有数字，所以让1接着和100左边的数字80比较

3.值1小于80， 因为80左边还有数字，所以让1接着和80左边的数字34比较

4.值1小于34，所以1放在34的左边，也就是最前面，{1, 34, 80, 100}

三、coding

1、lowb演示版

package com.chentongwei.struct.sort;

import java.util.Arrays;

/**
 * Description:
 *
 * @author TongWei.Chen 2020-01-07 17:05:54
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {100, 34, 80, 1};
        insertSort(arr);
    }

    /**
     * 逐步推导的方式
     *
     * @param arr：待排序的数组
     */
    private static void insertSort(int[] arr) {
        // 第一轮
        // {100, 34, 80, 1} =》{34, 100, 80, 1};
        // 定义待插入的数组
        int insertValue = arr[1];
        // 也就是arr[1]前面的数，因为要跟前面的数对比
        int insertIndex = 1 - 1;

        // 给insertValue找到插入的位置
        /*
         * 1.insertIndex >= 0 保证再给insertValue找插入位置的时候，不越界
         * 2.insertValue < arr[insertIndex] 说明待插入的值还没找到合适的位置，即需要将insertIndex往前移动，要让insertValue和其他值接着对比
         */
        while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
            // {100, 100, 80, 1};
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex --;
        }
        // 当退出while循环的时候代表插入的位置找到，位置是insertIndex+1的位置
        // {34, 100, 80, 1};
        arr[insertIndex + 1] = insertValue;
        System.out.println("第一轮插入：" + Arrays.toString(arr));

        // 第二轮
        // {34, 100, 80, 1} =》{34, 80, 100, 1};
        // 定义待插入的数组
        int insertValue2 = arr[2];
        // 也就是arr[1]前面的数，因为要跟前面的数对比
        int insertIndex2 = 2 - 1;
        while (insertIndex2 >= 0 && insertValue2 < arr[insertIndex2]) {
            arr[insertIndex2 + 1] = arr[insertIndex2];
            insertIndex2 --;
        }
        // 当退出while循环的时候代表插入的位置找到，位置是insertIndex+1的位置
        arr[insertIndex2 + 1] = insertValue2;
        System.out.println("第二轮插入：" + Arrays.toString(arr));

        // 第三轮
        // {34, 80, 100, 1} =》{1, 34, 80, 100}
        int insertValue3 = arr[3];
        int insertIndex3 = 3 - 1;
        while (insertIndex3 >= 0 && insertValue3 < arr[insertIndex3]) {
            arr[insertIndex3 + 1] = arr[insertIndex3];
            insertIndex3 --;
        }
        arr[insertIndex3 + 1] = insertValue3;
        System.out.println("第三轮插入：" + Arrays.toString(arr));
    }
}

第一轮插入：[34, 100, 80, 1]
第二轮插入：[34, 80, 100, 1]
第三轮插入：[1, 34, 80, 100]

2、优化版

lowb版明显发现硬编码，大量重复代码。如果数组长度是10000呢？那就写死了。但是规律很明显能发现出来：每次变化的地方就是insertValue和insertIndex两个变量的值 ，变化的规则就是每次都往后+1，因为每次都能确定一个值且放到最前面。所以下一轮就从前面+1开始就好了。规律找到了，那就很简单了，直接套层循环完事。

package com.chentongwei.struct.sort;

import java.util.Arrays;
/**
 * Description:
 *
 * @author TongWei.Chen 2020-01-07 17:05:54
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {100, 34, 80, 1};
        insertSortNew(arr);
    }

    private static void insertSortNew(int[] arr) {
        // 定义待插入的数组
        int insertValue;
        // 也就是arr[1]前面的数，因为要跟前面的数对比
        int insertIndex;
        for (int i = 1; i < arr.length; i ++) {
            // 定义待插入的数组
            insertValue = arr[i];
            // 也就是arr[1]前面的数，因为要跟前面的数对比
            insertIndex = i - 1;

            // 给insertValue找到插入的位置
            /*
             * 1.insertIndex >= 0 保证再给insertValue找插入位置的时候，不越界
             * 2.insertValue < arr[insertIndex] 说明待插入的值还没找到合适的位置，即需要将insertIndex往后移动，要让insertValue和其他值接着对比
             */
            while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                // 和之前的对比
                insertIndex --;
            }
            // 当退出while循环的时候代表插入的位置找到，位置是insertIndex+1的位置，这个判断是优化的手段
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertValue;
            }
            System.out.println("第" + i + "轮插入：" + Arrays.toString(arr));
        }
    }
}

第1轮插入：[34, 100, 80, 1]
第2轮插入：[34, 80, 100, 1]
第3轮插入：[1, 34, 80, 100]

四、性能测试

测试10w条数据，插入排序需要花费时间。

package com.chentongwei.struct.sort;

import java.util.Arrays;

/**
 * Description:
 *
 * @author TongWei.Chen 2020-01-07 17:05:54
 */
public class InsertSort {
    public static void main(String[] args) {
        // 测试选择排序的效率，假设给10w个数据测试
        int[] arr = new int[100000];
        for (int i = 0; i < arr.length; i ++) {
            // 生成【0，8000000】之间的一个随机数
            arr[i] = (int)(Math.random() * 8000000);
        }
        long startTime = System.currentTimeMillis();
        insertSortNew(arr);
        long endTime = System.currentTimeMillis();
        System.out.println("插入排序10w个数据所需要的时间是：" + (endTime - startTime) / 1000);
    }

    private static void insertSortNew(int[] arr) {
        // 定义待插入的数组
        int insertValue;
        // 也就是arr[1]前面的数，因为要跟前面的数对比
        int insertIndex;
        for (int i = 1; i < arr.length; i ++) {
            // 定义待插入的数组
            insertValue = arr[i];
            // 也就是arr[1]前面的数，因为要跟前面的数对比
            insertIndex = i - 1;

            // 给insertValue找到插入的位置
            /*
             * 1.insertIndex >= 0 保证再给insertValue找插入位置的时候，不越界
             * 2.insertValue < arr[insertIndex] 说明待插入的值还没找到合适的位置，即需要将insertIndex往后移动，要让insertValue和其他值接着对比
             */
            while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                // 和之前的对比
                insertIndex --;
            }
            // 当退出while循环的时候代表插入的位置找到，位置是insertIndex+1的位置
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertValue;
            }
        }
    }
}

插入排序10w个数据所需要的时间是：1

可以发现只需要1s，当然这和机器的配置有关，但是在我机器上测试的话插入>选择>冒泡的。我这测试20w条数据也仅需要4s而已。