[048] Java“插入排序算法”

1、插入排序

• Insert Sort，最简单的排序算法之一；
• 步骤：假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程；
• 趟数：n 个数据的数组，插入排序需要排 n-1 趟才能完成排序；
• 复杂度：平均时间复杂度为O(n^2)；
• 稳定性：两个相等的数的相对顺序不会发生改变，则该算法是稳定的。所以插入排序是一种稳定算法。

2、Java代码

package Algorithm.Sort;

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

/**
 * @author yhx
 * @date 2020/09/30
 */
public class InsertSort {
    private static final int NUM = 100;
    public static void main(String[] args) {
        int[] arr1 = {101, 34, 119, 1};
        int[] arr2 = {101, 34, 119, 1};
        int[] arr3 = new int[NUM];
        for (int i = 0; i < NUM; i++) {
            // .random()用于产生一个0到1的随机小数
            arr3[i] = (int) ((Math.random() * 2 - 1) * NUM);
        }

        // 插入排序步骤演示
        System.out.println("插入排序的基本步骤：");
        Insert insert = new Insert();
        insert.insertSortProcess(arr1);
        System.out.println();

        // 整合过的插入排序
        insert.insert(arr2);
        System.out.println("整合过的插入排序：arr2[] = " + Arrays.toString(arr2));
        System.out.println();

        // 用大量数据测试优化后的冒泡排序的排序速度
        System.out.println("优化后的插入排序综合演示：");
        // Date()函数用于标记时间
        Date date1 = new Date();
        // 时间标记精确到毫秒
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("arr3[]排序前的时间是：" + date1Str);

        insert.insert(arr3);

        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("arr3[]排序后的时间是：" + date2Str);

        System.out.println("arr3[]插入排序后的结果为：" + Arrays.toString(arr3));

    }
}

/**
 * 插入排序算法的两种方法
 */
class Insert {
    /**
     * 插入排序基础步骤演示
     *
     * @param arr 待排序数组
     */
    public void insertSortProcess(int[] arr) {
        //第一趟
        // 趟数，也表示待插入数据的所在的索引
        int round = 1;
        // 待插入数据
        int insertVal = arr[round];
        // 待插入数据的前一个数据
        int insertIndex = 0;

        /*
        找到insertVal的插入位置
        1、insertIndex >= 0保证不越界
        2、若insertVal < arr[insertIndex]，说明待插入数据还要向前移动
         */
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            // 待插入数据的前一个数据后移一位
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        // 当退出循环时，说明插入的位置找到：insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        System.out.println("插入算法第一趟执行后，arr1[] = " + Arrays.toString(arr));

        //第二趟
        // 趟数，也表示待插入数据的所在的索引
        round = 2;
        // 待插入数据
        insertVal = arr[round];
        // 待插入数据的前一个数据
        insertIndex = round - 1;

        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            // 待插入数据的前一个数据后移一位
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        // 当退出循环时，说明插入的位置找到：insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        System.out.println("插入算法第二趟执行后，arr1[] = " + Arrays.toString(arr));

        //第三趟
        // 趟数，也表示待插入数据的所在的索引
        round = 3;
        // 待插入数据
        insertVal = arr[round];
        // 待插入数据的前一个数据
        insertIndex = round - 1;

        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            // 待插入数据的前一个数据后移一位
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        // 当退出循环时，说明插入的位置找到：insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        System.out.println("插入算法第三趟执行后，arr1[] = " + Arrays.toString(arr));
    }

    /**
     * 整合优化过的插入排序算法
     * @param arr 待排序数组
     */
    public void insert(int[] arr) {
        // i表示趟数，也表示待插入数据的所在的索引
        for (int i = 1; i < arr.length; i++) {
            // 待插入数据
            int insertVal = arr[i];
            // 待插入数据的前一个数据
            int insertIndex = i- 1;

        /*
        找到insertVal的插入位置
        1、insertIndex >= 0保证不越界
        2、若insertVal < arr[insertIndex]，说明待插入数据还要向前移动
         */
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                // 待插入数据的前一个数据后移一位
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            // 当退出循环时，说明插入的位置找到：insertIndex + 1
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
    }
}

3、运行结果

插入排序的基本步骤：
插入算法第一趟执行后，arr1[] = [34, 101, 119, 1]
插入算法第二趟执行后，arr1[] = [34, 101, 119, 1]
插入算法第三趟执行后，arr1[] = [1, 34, 101, 119]

整合过的插入排序：arr2[] = [1, 34, 101, 119]

优化后的插入排序综合演示：
arr3[]排序前的时间是：2020-09-30 11:46:05:296
arr3[]排序后的时间是：2020-09-30 11:46:05:330
arr3[]插入排序后的结果为：[-99, -99, -95, -94, -91, -89, -88, -87, -82, -80, -79, -75, -73, -72, -70, -69, -66, -62, -57, -56, -53, -53, -52, -52, -50, -47, -46, -42, -39, -35, -35, -35, -33, -32, -30, -28, -24, -21, -18, -17, -15, -12, -11, -11, -10, -7, -7, -6, 4, 7, 10, 11, 13, 13, 15, 16, 16, 19, 19, 19, 20, 22, 25, 34, 34, 36, 37, 37, 38, 39, 40, 43, 43, 43, 44, 47, 48, 51, 57, 59, 64, 69, 75, 76, 80, 81, 82, 84, 85, 88, 88, 91, 92, 93, 94, 94, 97, 97, 98, 99]