跳转至

# 插入排序

本页面将简要介绍插入排序．

## 定义

插入排序（英语：Insertion sort）是一种简单直观的排序算法．它的工作原理为将待排列元素划分为「已排序」和「未排序」两部分，每次从「未排序的」元素中选择一个插入到「已排序的」元素中的正确位置．

一个与插入排序相同的操作是打扑克牌时，从牌桌上抓一张牌，按牌面大小插到手牌后，再抓下一张牌．

## 性质

### 稳定性

插入排序是一种稳定的排序算法．

### 时间复杂度

插入排序的最优时间复杂度为 𝑂(𝑛)O(n)，在数列几乎有序时效率很高．

插入排序的最坏时间复杂度和平均时间复杂度都为 𝑂(𝑛 2)O(n 2)．

## 代码实现

### 伪代码

1 𝐈 𝐧 𝐩 𝐮 𝐭. A n a r r a y 𝐴 c o n s i s t i n g o f 𝑛 e l e m e n t s.2 𝐎 𝐮 𝐭 𝐩 𝐮 𝐭. 𝐴 w i l l b e s o r t e d i n n o n d e c r e a s i n g o r d e r s t a b l y.3 𝐌 𝐞 𝐭 𝐡 𝐨 𝐝. 4 𝐟 𝐨 𝐫 𝑖←2 𝐭 𝐨 𝑛 5 𝑘 𝑒 𝑦←𝐴[𝑖]6 𝑗←𝑖−1 7 𝐰 𝐡 𝐢 𝐥 𝐞 𝑗>0 𝐚 𝐧 𝐝 𝐴[𝑗]>𝑘 𝑒 𝑦 8 𝐴[𝑗+1]←𝐴[𝑗]9 𝑗←𝑗−1 1 0 𝐴[𝑗+1]←𝑘 𝑒 𝑦 1 Input. An array A consisting of n elements.2 Output. A will be sorted in nondecreasing order stably.3 Method. 4 for i←2 to n 5 k e y←A[i]6 j←i−1 7 while j>0 and A[j]>k e y 8 A[j+1]←A[j]9 j←j−1 10 A[j+1]←k e y
C++Python Java

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    void insertion_sort(int arr[], int len) {
      for (int i = 1; i < len; ++i) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
          arr[j + 1] = arr[j];
          j--;
        }
        arr[j + 1] = key;
      }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    def insertion_sort(arr, n):
        for i in range(1, n):
            key = arr[i]
            j = i - 1
            while j >= 0 and arr[j] > key:
                arr[j + 1] = arr[j]
                j -= 1
            arr[j + 1] = key

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

## 折半插入排序

插入排序还可以通过二分算法优化性能，在排序元素数量较多时优化的效果比较明显．

### 时间复杂度

折半插入排序与直接插入排序的基本思想是一致的，折半插入排序仅对插入排序时间复杂度中的常数进行了优化，所以优化后的时间复杂度仍然不变．

### 代码实现

C++

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    void insertion_sort(int arr[], int len) {
      if (len < 2) return;
      for (int i = 1; i != len; ++i) {
        int key = arr[i];
        auto index = upper_bound(arr, arr + i, key) - arr;
        // 使用 memmove 移动元素，比使用 for 循环速度更快，时间复杂度仍为 O(n)
        memmove(arr + index + 1, arr + index, (i - index) * sizeof(int));
        arr[index] = key;
      }
    }

> 本页面最近更新：2026/1/7 08:56:54，更新历史
> 发现错误？想一起完善？ 在 GitHub 上编辑此页！
> 本页面贡献者：NachtgeistW, H-J-Granger, StudyingFather, countercurrent-time, Enter-tainer, Junyan721113, Konano, Tiphereth-A, AngelKitty, CCXXXI, cjsoft, diauweb, Early0v0, ezoixx130, GekkaSaori, iamtwz, Ir1d, LovelyBuggies, Makkiy, mgt, minghu6, P-Y-Y, PotassiumWings, SamZhangQingChuan, sshwy, Suyun514, weiyong1024, AprilNEA, c-forrest, clee01, EmptyDreams, GavinZhengOI, Gesrua, Great-designer, hsfzLZH1, ksyx, kxccc, lychees, mcendu, Menci, Molly166, ouuan, partychicken, Peanut-Tang, shawlleyw, SukkaW, thy233, TrickEye, Xeonacid
> 本页面的全部内容在 CC BY-SA 4.0 和 SATA 协议之条款下提供，附加条款亦可能应用