原理

插入排序是一种简单的排序算法，它将待排序的序列看作两部分，左半部分已经有序，右半部分则是乱序，初始状态下，左半部分只有一个元素，整个排序过程就是从第二个元素开始，不断地依次从右边乱序部分中取出元素，放到左边有序部分中的合适位置，直到最后右边乱序部分中的元素全部被取走，整个序列就被排好序了。

与其他高级排序算法（比如快速排序、堆排序、归并排序）相比，插入排序算法的效率低得多，但是这并不意味着它毫无用，天生我材必有用，插入排序算法也是有几项优点的：

1. 容易用代码实现。在《编程珠玑》中，Jon Bentley 用 3 行 C 语言代码就写出了插入排序算法，然后，他又给出了一个 5 行的优化版本。可见插入排序算法实现起来是多么的简单。
2. 当待排序的序列规模较小时，插入排序的效率还是比较高的。
3. 与其他简单的二次排序算法（比如冒泡排序、快速排序）相比，插入排序算法在实践中效率更高。
4. 当待排序的序列基本有序时，插入排序的效率是最高的，时间复杂度可为 O(nk)，其中 k 指的是在任何一趟排序中，待排序的元素距离它的合适位置都不会超过 k 个元素。
5. 稳定。如果序列中有两个或多个元素的值相同，那么在排序后他们的相对位置不会发生变化。
6. 就地算法。插入排序的空间复杂度为 O(1)，排序过程中不会占用额外的空间。
7. 在线。能够边接收值边排序。

在线: 在计算机科学中，在线算法是以串行方式逐块处理输入的算法，即，按照值被输入到算法的顺序，而不需要从一开始就使得整个序列可用。

更多关于插入排序的细节，请参考：维基百科-插入排序

插入算法图示 / 维基百科

插入排序算法不仅可以对数组进行排序，还可以对链表进行排序，接下来我们就看一下插入排序的具体实现方式。

基于数组的插入排序算法

根据上述插入排序思想，用 C++ 实现如下：

#include <iostream>

using namespace std;

/*对数组A[low, high)进行排序*/
void insertionSort(int A[], int low, int high) {
    for (int i = low + 1; i < high; i++) { //从第 2 个元素开始迭代
        int temp = A[i]; //备份 A[i]
        int pos = i - 1;
        while (pos >= low && A[pos] > temp)
            A[pos + 1] = A[pos--];
        A[++pos] = temp;
    }
}

int main() {
    int A[8] = { 6, 5, 3, 1, 8, 7, 2, 4 };
    insertionSort(A, 0, 8);
    
    for (int i = 0; i < 8; i++)
        cout << A[i] << " ";
    cout << endl; cout << endl;
    system("pause"); return 0;
}

程序运行结果如下图所示：

程序运行结果

程序运行过程示意图：

程序运行过程示意图 / 维基百科

基于链表的插入排序

这一节的代码是基于上篇文章中的双向链表来写的，用到了双向链表中的几个接口，链表也是一个很重要的数据结构，没有看过那篇文章的读者可以看一下：手把手教你实现一个链表，下面是本文代码中用到的部分链表提供的接口。

操作接口	功能	适用对象
size()	报告当前列表的规模（节点总数）	列表
first()、last()	返回首、末节点的位置	列表
insertAsLast(e)	将 e 当作末节点插入	列表
insertAfter(p, e)	将 e 当作节点 p 的直接后继插入	列表
remove(p)	删除位置p处的节点，返回其数值	列表
sort()	调整各节点的位置，使之按非降序排列	列表
search(e)	查找目标元素 e，返回不大于 e 且秩最大的节点	有序列表

下面是 C++ 实现代码，代码中用到的头文件 LinkedKist.h 已上传至GitHub，点击这里可获得。

#include <iostream>
#include "LinkedList.h"

using namespace std;

/*对起始于位置 p 的 n 个元素排序*/
template <typename T>
void insertionSort(LinkedList<T> &list, ListNode<T>* p, int n) {
    for (int r = 0; r < n; r++) { //逐一为各节点
        ListNode<T>* pos = list.search(p->data, r, p); //查找合适的位置，p->data指的是节点 p 中存储的数据
        list.insertAfter(pos, p->data); //插入
        p = p->succ; //令 p 指向它的后继
        list.remove(p->pred); //删除 p 的前驱
    }
}

int main() {
    LinkedList<int> list; //创建一个LinkedList对象
    
    //向链表中插入数据
    list.insertAsLast(6); //作为末节点插入
    list.insertAsLast(5);
    list.insertAsLast(3);
    list.insertAsLast(1);
    list.insertAsLast(8);
    list.insertAsLast(7);
    list.insertAsLast(2);
    list.insertAsLast(4);

    ListNode<int>* p = list.first(); //获取首节点的引用，令 p 指向首节点

    int n = list.size(); //list.size()是获取链表的规模（即链表中的节点数）
    insertionSort(list, p, n); //对链表使用插入排序

    p = list.first(); //令 p 指向首节点
    for (int i = 0; i < n; i++) {
        cout << p->data << " "; //p->data 指的是节点 p 中存储的数据
        p = p->succ; //令 p 指向 p 的后继
    }
    cout << endl; cout << endl;
    system("pause"); return 0;
}

下面是程序运行结果：

总结

不管是基于数组的插入排序还是基于链表的插入排序，在最坏情况下，第 i 次迭代都需要花费 O(i) 的时间去寻找合适的位置，因此总的下来，插入排序的时间复杂度为 。而在最好情况下，也就是序列已经按非降序排列，这时，插入排序的时间复杂度仅为 。

在空间复杂度方面，正如文章开头我们说的，插入排序是一种就地排序算法，仅需常量个数的额外的存储单元来存放当前待排序的元素。因此插入排序的空间复杂度为 。

欢迎关注我的微信公众号，扫描下方二维码或微信搜索：AProgrammer，就可以找到我，我会持续为你分享 IT 技术。