1. 基本介绍

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

2. 插入排序法思想

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

3. 插入排序思路图

• 原始的数组 ： 101在有序表中，其他在无序表
  101, 34, 119, 1
• 第一轮排序 : 34作为无序表第一个元素和有序表中的元素进行比较交换
  34, 101, 119, 1
• 第二轮排序 : 119作为无序表第一个元素和有序表中的元素进行比较交换，这里119比有序表中元素都大，所以不需要交换
  34, 101, 119, 1
• 第三轮排序 : 1作为无序表第一个元素和有序表中的元素进行比较交换
  1, 34, 101, 119

4. 代码实现

import java.util.Arrays;

public class InsertSort {

    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
        analysisProcess(arr);

        int[] arr2 = {101, 34, 119, 1, -1, 89};
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr2));
        insertSort(arr2);
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr2));

    }

    /**
     * 推导排序过程
     * 假设原始数组{101, 34, 119, 1}
     *
     * @param arr
     */
    public static void analysisProcess(int[] arr) {
        // 第1轮
        // 待插入的数，从第2位开始，第1位假定的最小的
        int insertVal = arr[1];
        // 即arr[1]前面的那个数的下表
        int insertIndex = 1 - 1;

        // 给insertVal找到要插入的位置
        // 1. insertIndex >= 0 保证不越界
        // 2. insertVal < arr[insertIndex] 这个待插入的数需要交换位置
        // 3. arr[insertIndex + 1] = arr[insertIndex] 将 arr[insertIndex]后移
        // 4. insertIndex--下标前移
        // 数组从{101,34,119,1};到 => {101,101,119,1}
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        // 当退出while循环时，说明已经找到待插入的位置，将insertVal赋值到这个位置
        // 但是insertIndex多--了一次，这里需要+1
        // 如果 insertIndex + 1 == 1 说明没有进入while循环，即insertVal >= arr[insertIndex]，则不需要进行赋值操作
        // 数组从{101,101,119,1};到 => {34,101,119,1}
        if (insertIndex + 1 != 1) {
            arr[insertIndex + 1] = insertVal;
        }
        System.out.println("第1轮插入结果");
        System.out.println(Arrays.toString(arr));

        // 第2轮
        insertVal = arr[2];
        insertIndex = 2 - 1;
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        if (insertIndex + 1 != 2) {
            arr[insertIndex + 1] = insertVal;
        }
        System.out.println("第2轮插入结果");
        System.out.println(Arrays.toString(arr));

        // 第3轮
        insertVal = arr[3];
        insertIndex = 3 - 1;
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        if (insertIndex + 1 != 3) {
            arr[insertIndex + 1] = insertVal;
        }
        System.out.println("第3轮插入结果");
        System.out.println(Arrays.toString(arr));
    }

    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;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

• 结果打印

排序前
[101, 34, 119, 1]
第1轮插入结果
[34, 101, 119, 1]
第2轮插入结果
[34, 101, 119, 1]
第3轮插入结果
[1, 34, 101, 119]
排序前
[101, 34, 119, 1, -1, 89]
排序后
[-1, 1, 34, 89, 101, 119]
1
2
3
4
5
6
7
8
9
10
11
12