数据结构之排序(1)——插入排序

插入排序主要包括三个：直接插入排序、折半插入排序和希尔排序。基本思想都是：

每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中，直到全部记录插入完成。

下面依次进行讲解并编程实现。

直接插入排序

主要思想：
1. 循环i从1~n-1，每次循环执行步骤2-4。
2. 查找arr[i]在arr[0]~arr[i-1]的插入位置k。
3. 将arr[k]~arr[i-1]每个元素后移一个位置。
4. 将arr[i]复制到arr[k]。

如图所示：

时间复杂度：

• 最好情况下，每次循环只需和arr[i-1]比较，并不用移动，为$O(n)$。
• 最差情况下，下标为i的元素要和前面i个元素都比较一下，则一共比较次数为$\sum_{i=1}^{n-1}i$，即$(n^2-n)/2$次；移动次数也最大，为$\sum_{i=1}^{n-1}i+1$，因为还有基准元素赋到第一位，所以多了1，复杂度为$O(n^2)$。

平均下来，约为$((n^2+n)/4)$次，复杂度为$O(n^2)$。
稳定性：稳定
适用性：用顺序表时，从后往前比较，比较后直接交换；单链表的话，从前往后查找。

不带哨兵

核心代码如下：

void insertSort(int arr[], int n)
{
    int i, j;
    int tmp;
    for (i = 1; i < n; ++i){
        if (arr[i] < arr[i - 1]){
            tmp = arr[i];
            for (j = i - 1; tmp < arr[j] && j>=0; --j)
                arr[j + 1] = arr[j];
            arr[j + 1] = tmp;
        }
    }
}

带哨兵

更一般的，可以引入哨兵arr[0]，（哨兵：简化边界条件而引入的附加结点）有两个作用：
1. 可以减少临界的比较，即不用比较j>=0
2. 暂时存放待插入的元素

如下：

void insertSort(int arr[], int n)//这里n是待排序数个数，不包括哨兵
{
    int i, j;
    for (i = 2; i <= n; ++i){
        if (arr[i] < arr[i - 1]){
            arr[0] = arr[i];
            for (j = i - 1; arr[0] < arr[j]; --j)
                arr[j + 1] = arr[j];
            arr[j + 1] = arr[0];
        }
    }
}

拓展：元素为结构时

如果待排序的是结构的话，也一样：

#include <iostream>
using namespace std;

struct Elem
{
    int key;
    Elem(){}
    Elem(int key) :key(key){}
    bool operator < (const Elem& other)
    {
        return this->key < other.key;//升序排列
    }
    Elem& operator = (const Elem& other)
    {
        this->key = other.key;
        return *this;
    }
    friend ostream& operator << (ostream &stream, const Elem &e)
    {
        stream << e.key;
        return stream;
    }
};
void print(Elem arr[], int n, int i)
{
    cout << "第" << i << "轮：";
    for (int i = 0; i < n; ++i){
        cout << " " << arr[i];
    }
    cout << endl;
}
void insertSort(Elem arr[], int n)
{
    int i, j;
    for (i = 2; i <= n; ++i){
        if (arr[i] < arr[i - 1]){
            arr[0] = arr[i];
            for (j = i - 1; arr[0] < arr[j]; --j)
                arr[j + 1] = arr[j];
            arr[j + 1] = arr[0];
        }
        print(arr, n+1, i-1);
    }
}
int main()
{
    Elem arr[9] = { { 0 },{ 6 }, { 5 }, { 3 }, { 1 }, { 8 }, { 7 }, { 2 }, { 4 } };
    print(arr, 9, 0);
    insertSort(arr, 8);
    system("pause");
}

第0轮： 0 6 5 3 1 8 7 2 4
第1轮： 5 5 6 3 1 8 7 2 4
第2轮： 3 3 5 6 1 8 7 2 4
第3轮： 1 1 3 5 6 8 7 2 4
第4轮： 1 1 3 5 6 8 7 2 4
第5轮： 7 1 3 5 6 7 8 2 4
第6轮： 2 1 2 3 5 6 7 8 4
第7轮： 4 1 2 3 4 5 6 7 8

折半插入排序

思路是：由于前一部分是已排序的，所以不再一次次比较，而是二分查找到待插入元素应该在哪个位子，再插入，后移操作统一放到一起。

void insertSort(int arr[], int n)
{
    int i, j, low, mid, high;
    for (i = 2; i <= n; ++i){
        arr[0] = arr[i];
        low = 1; high = i - 1;
        while (low <= high){
            mid = (low + high) / 2;
            if (arr[mid] > arr[0]) 
                high = mid - 1;
            else low = mid + 1;//相等的话，插到后面，算法稳定
        }
        for (j = i - 1; j>=high+1 ; --j)//high+1到i-1的数后移
            arr[j + 1] = arr[j];
        arr[high + 1] = arr[0];//待插入数放到high+1
    }
}

用了二分查找仅减少了比较的复杂度，从$O(n^2)$到$O(nlog_2n)$，且次数与数列初始状态无关，仅取决于个数n，即最好情况最差情况都是这么多。
移动次数仍然一样，但移动次数与数列初始状态有关，最好情况为0，最差情况复杂度为$O(n^2)$；

故总的来说，时间复杂度

• 最好情况为$O(nlog_2n)$，仅用在查找，不移动。
• 最差情况为$O(n^2)$，移动+查找。

平均为$O(n^2)$。
稳定性：稳定。
空间复杂度：$O(1)$

希尔排序

基本思路：先将待排序表分割成若干个形如$L[i,i+d,i+2d,...i+kd]$的特殊子表，分别进行直接插入排序，随着$d$不断减小至1，整个表也会趋向于“基本有序”，最后$d$为1时，进行一次整体的直接插入排序。

和直接插入相比，算法修改为：
1. 前后比较增量为dk，不是1。
2. arr[0]不再是哨兵，而仅作为暂时存储用，即判断越界用不到了。

void shellSort(int arr[], int n)
{   
    int dk, i, j;//dk为增量
    for (dk = n / 2; dk >= 1; dk = dk / 2){
        for (i = dk + 1; i <= n; ++i){
            if (arr[i] < arr[i - dk]){
                arr[0] = arr[i];
                for (j = i - dk; j>0 && arr[0]<arr[j]; j -= dk)
                    arr[j + dk] = arr[j];
                arr[j + dk] = arr[0];
            }
        }
    }
}

空间复杂度：用了3个辅助单元，为$O(1)$
时间复杂度：依赖于增量序列的函数。
稳定性：不稳定。
适用性：仅适用于顺序存储的线性表。（因为增量不为1，要能以常数时间访问到任何一个元素，链式就不行了。）

各算法复杂度表

算法	平均时间复杂度	最好时间复杂度	最差时间复杂度	空间复杂度	稳定性	备注
直接插入排序	$O(n^2)$	$O(n)$	$O(n^2)$	$O(1)$	稳定
折半插入排序	$O(n^2)$	$O(nlog_2n)$	$O(n^2)$	$O(1)$	稳定
shell排序	$O(n^{1.3})$	$O(n)$	$O(n^2)$	$O(1)$	不稳定	和增量序列有关