插入排序总结

所谓插入排序，就是把一组乱序的数据，依次拿出一个，放入到一组已经排好序的数据中的正确的位置。又可以分为：①直接插入排序、②折半插入排序、③二路插入排序、④表插入排序、⑤希尔排序、

一、直接插入排序：

相对比较简单的一种排序方法，就是按照概念一步一步的操作，可以使用一个for循环实现，具体代码如下：

//直接插入排序
void StrInsertSort(SeqList &s, int n) 
{
    for(int i=1; i<n; i++)
    {
        if(s[i] < s[i-1])
        {
            Swap(&s[i], &s[i-1]);
            for(int j=i-1; j>0&&s[j]<s[j-1]; j--)
            {
                Swap(&s[j], &s[j-1]);
            }
        }
    }
}

 

注意：这里假设按照从小到大的顺序排序（1）从第二个数据（下标为1的数据）开始，一直到最后一个数据结束，每次取出一个数据。（2）比较第一步的数据和它前一个位置的数据，如果大于前一个位置的数据，则交换两者。再开始和前面的数据依次比较，并和比它大的数据进行交换，因为前面的数据已经有序，则找到第一个比它小的数据后就退出。

解析：直接插入排序由于每次比较之后，如果不符合排序规则就需要进行一次交换，效率并不是很高。因此可以通过一定的方法，来减少数据交换的次数。可以使用下标为零的位置作为零空间，用来保存每次取到的待插入的数据。每次比较之后，如果需要交换，只是拿前一个位置的数据覆盖待排序的数据（这里不用担心数据丢失，因为它已经保存在了零空间中）。一直到退出循环后，把零空间中的数据赋值到退出时的位置（注意分析下标）。具体代码如下：

//直接插入排序 //使用零空间
void StrInsertSort2(SeqList &s, int n)
{
    for(int i=2; i<n; i++)
    {
        if(s[i] < s[i-1])
        {
            s[0] = s[i];
            s[i] = s[i-1];

            for(int j=i-2; s[0]<s[j]; j--)
            {
                
                s[j+1] = s[j];
            }
            s[j+1] = s[0];
        }
    }
}

 

 

二、折半插入排序：

使用零空间的直接插入排序虽然减少了数据的移动次数，但是并没有减少数据的比较次数，我们可以设法减少数据的比较次数，因此就有了折半插入排序。

所谓折半插入，就是利用前面的数据已经有序的特性，每次和前面数据中中间位置的数据进行比较。如果小于，往前半部分插入，如果大于或者等于（为了保持稳定），往后半部分插入。可以使用零空间减少数据移动的次数。具体代码：​

//折半插入排序
void BinInsertSort(SeqList &s, int n)
{
    for(int i=2; i<n; i++)
    {
        s[0] = s[i];
        int low = 1;
        int high = i-1;
        while(low <= high)
        {
            int mid = (low+high)/2;
            if(s[0] >= s[mid])
            {
                low = mid+1;
            }
            else{
                high = mid-1;
            }
        }

        for(int j=i; j>high+1; j--)
        {
            s[j] = s[j-1];
        }
        s[high+1] = s[0];
    }
}

 

三、二路插入排序

 二路，就是把待插入的数据往两个不同的方向进行插入，具体往哪个方向，要看它比一组已经有序的数据的头部的小，还是比尾部的大。如果比头部的小就在头部之前插入，如果比尾部的大就在尾部之后插入，否则从尾部开始，进行直接插入排序。使用二路插入排序，可以减少数据的比较次数。这里为了方便使用了等长的辅助空间。

//二路插入排序
void TwoWayInsertSort(SeqList &s, int n)
{
    SeqList t;
    t[0] = s[0];
    int head, tail;
    head = tail = 0;

    for(int i=1; i<n; i++)
    {
        if(s[i] < t[head])
        {
            head = (head-1+n)%n;
            t[head] = s[i];
        }
        else if(s[i] > t[tail])
        {
            tail++;
            t[tail] = s[i];
        }
        else{
            tail++;
            t[tail] = t[tail-1];
            for(int j=tail-1; s[i]<t[(j-1+n)%n]; j=(j-1+n)%n)//注意循环退出条件
            {
                t[j] = t[(j-1+n)%n];//注意下标
            }
            t[j] = s[i];
        }
    }

    for(i=0; i<n; i++)
    {
        s[i] = t[head];
        head = (head+1)%n;
    }
}

 

四、表插入排序

可以看做是往已经有序的静态链表中插入一条数据，每次插入只修改结点的指针域，不用移动数据。排序完成后对数据进行重排列。同时可以使用零空间减少移动次数（这里指修改下标的次数）。

#define MAXVALUE 0x7fffffff

typedef struct SLNode
{
    ElemType data;
    int      link;
}SLNode;

typedef SLNode Table[MAXSIZE];

//表插入排序
void TableInsertSort(Table &s, int n)
{
    s[0].link = 1;
    int p,q;
    for(int i=2; i<n; i++)
    {
        p = s[0].link;
        q = 0;
        while(p!=0 && s[p].data<=s[i].data)
        {
            q = p;
            p = s[p].link;
        }
        s[i].link = s[q].link;
        s[q].link = i;
    }
}

 

五、希尔排序

将待排序数据分割为若干个子序列，分别对子序列进行直接插入排序，子序列排序完之后整体已经基本有序，然后再对所有数据进行一次直接插入排序。希尔排序使用的增量序列的取法要值的注意，目前还没有一个最好的增量序列，但应使增量序列中没有除1之外的公因子，并且最后一个值必须等于1。

//希尔排序
void ShellSort(SeqList &s, int n, int dlta[], int t)
{
    for(int i=0; i<t; i++)
    {
        ShellSort(s, n, dlta[i]);
    }
}

void ShellSort(SeqList &s, int n, int dk)
{
    for(int i=dk+1; i<n; i++)
    {
        if(s[i] < s[i-dk])
        {
            s[0] = s[i];
            for(int j=i-dk; j>0&&s[0]<s[j]; j-=dk)
            {
                s[j+dk] = s[j];
            }
            s[j+dk] = s[0];
        }
    }
}

 

祝大家学习愉快，工作顺利。