当前位置：首页 > article >正文

深入浅出：插入排序算法完全解析

article 2025/2/28 11:33:12

1. 什么是插入排序？

插入排序（Insertion Sort）是一种简单的排序算法，其基本思想与我们整理扑克牌的方式非常相似。我们将扑克牌从第二张开始依次与前面已排序的牌进行比较，将其插入到合适的位置，直到所有牌都有序。

插入排序是一种逐步构建有序序列的算法，每次从未排序部分中取出一个元素，并将其插入到已排序部分的合适位置。

2. 插入排序的基本思想

插入排序的基本思想是逐步构建一个有序的序列。它将数组分为两部分：已排序部分和未排序部分。每次将未排序部分的第一个元素插入到已排序部分的合适位置，直到整个数组有序。

插入排序的具体步骤：

将第一个元素看作已排序的部分。
从第二个元素开始，将当前元素与已排序部分的元素进行比较。
如果当前元素小于已排序部分的元素，则将已排序部分的元素向右移动一个位置，为当前元素腾出空间。
将当前元素插入到合适的位置。
重复步骤2到步骤4，直到所有元素都插入到正确的位置。

插入排序的过程可以通过下面的动画来帮助理解：

假设我们有以下无序数组：

[5, 2, 9, 1, 5, 6]

插入排序的过程如下：

初始状态：[5, 2, 9, 1, 5, 6]
插入第二个元素 2：[2, 5, 9, 1, 5, 6]
插入第三个元素 9：[2, 5, 9, 1, 5, 6]
插入第四个元素 1：[1, 2, 5, 9, 5, 6]
插入第五个元素 5：[1, 2, 5, 5, 9, 6]
插入第六个元素 6：[1, 2, 5, 5, 6, 9]

最终排序后的数组：[1, 2, 5, 5, 6, 9]

3. 插入排序的伪代码

for i = 1 to n-1:          // 从第二个元素开始
    current = arr[i]       // 当前元素
    j = i - 1              // 已排序部分的最后一个元素
    while j >= 0 and arr[j] > current:   // 逐步向前查找插入位置
        arr[j + 1] = arr[j]                // 将大于当前元素的值向右移动
        j -= 1
    arr[j + 1] = current    // 将当前元素插入合适位置

过程说明：

外循环（for i = 1 to n-1）：从第二个元素开始，逐步将当前元素插入到已排序的部分。
内循环（while j >= 0 and arr[j] > current）：比较当前元素与已排序部分的元素，并将大于当前元素的元素向右移动。
插入操作：在找到合适位置后，将当前元素插入到空位置。

4. 插入排序的时间复杂度分析

插入排序的时间复杂度取决于输入数据的顺序。

最优情况（已经排好序）：每次比较时都无需移动元素，只进行一次比较。此时时间复杂度为 O(n)。
最坏情况（完全逆序）：每个元素都需要与已排序部分的每个元素进行比较并移动。因此，时间复杂度为 O(n²)。
平均情况：假设数据是随机排列的，插入排序的平均时间复杂度也是 O(n²)。

空间复杂度：

插入排序只使用常数级的额外空间（只需一个临时变量来保存当前元素），因此它的空间复杂度是 O(1)。

总结：

最佳时间复杂度：O(n)，当输入数组已经有序时。
最坏时间复杂度：O(n²)，当输入数组完全逆序时。
平均时间复杂度：O(n²)，适用于随机排列的数据。
空间复杂度：O(1)，是一个原地排序算法。

5. 插入排序的优缺点

优点：

简单易懂：插入排序的算法实现非常简单，适合用来讲解排序的基本思想。
空间复杂度低：它是原地排序算法，不需要额外的空间（只需常数级别的空间）。
适用于小数据量：当数据量较小或数据已经部分有序时，插入排序的效率较高。
稳定排序：插入排序是一种稳定排序算法，意思是相等的元素不会交换位置，保留原有的顺序。

缺点：

时间复杂度高：对于大数据量的排序，时间复杂度为 O(n²)，性能较差，不适合大规模数据的排序。
不适用于大数据集：对于大规模数据，插入排序会表现得很慢，通常选择更高效的排序算法，如快速排序、归并排序等。

6. 插入排序的代码实现（Java）

Java 实现：

import java.util.Arrays;

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        // 从第二个元素开始
        for (int i = 1; i < arr.length; i++) {
            int current = arr[i];    // 当前元素
            int j = i - 1;           // 已排序部分的最后一个元素
            
            // 查找插入位置
            while (j >= 0 && arr[j] > current) {
                arr[j + 1] = arr[j];  // 将大于当前元素的值向右移动
                j--;
            }
            
            arr[j + 1] = current;    // 插入当前元素
        }
    }

    public static void main(String[] args) {
        int[] arr = { 5, 2, 9, 1, 5, 6 };
        System.out.println("Before sorting: " + Arrays.toString(arr));
        
        insertionSort(arr);
        
        System.out.println("After sorting: " + Arrays.toString(arr));
    }
}

输出：

Before sorting: [5, 2, 9, 1, 5, 6]
After sorting: [1, 2, 5, 5, 6, 9]

代码解析：

初始化：从数组的第二个元素开始，假设第一个元素已经是有序的。
查找插入位置：通过 while 循环，逐步将当前元素与已排序部分的元素进行比较，并向右移动大于当前元素的元素。
插入当前元素：找到正确的插入位置后，将当前元素插入到该位置。

7. 应用场景

小规模数据：当数据量较小或基本有序时，插入排序非常高效。由于它的时间复杂度较低（O(n)）在数据已经排序的情况下，插入排序会比其他复杂的排序算法（如快速排序）更快。
实时数据：插入排序适用于不断接收数据并需要立即排序的场景，例如在实时系统中，插入新数据时只需将数据插入到已排序的部分。
链表排序：对于链表结构，插入排序比其他排序算法（如快速排序）更有效，因为链表本身在插入操作时更为高效。