本文主要是介绍算法之插入排序，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、排序的概念

1.排序：

将一组杂乱无章的数据按一定规律顺次排列起来。将无序序列排成一个有序序列（由大到小或由小到大）运算。

如果参加排序的数据结点包含多个数据域，那么排序往往是正对某一个数据域。

2.存储结构：

#define MAXSIZE 20    // 记录不超过20个
typedef int KeyType    // 设置别名关键字
Typedef struct {        // 定义每个记录(数据元素)的结构
    KeyType    key；// 关键字
    lnfoType    otherinfo    // 其他数据项
}RefType

Typedef struct {    // 定义顺序表的结构
    RedType r[MAXSIZE +1 ]        // 存储顺序表的向量，r[0]一般做哨兵或者缓冲区
    int length    // 顺序表的长度
}SqList

3.算法

1.思想

每一步将一个待排序的对象，按其关键码大小，插入到前面已经排好序的一组对象的适当位置上，直到对象全部插入为止。

即：边插入边排序，保证子序列中随时都是排好序的。

2.插入排序的种类：

1.顺序法，定位插入位置—直接插入排序

2.二分法，定位插入位置—二分插入排序

3.缩小增量，多编插入排序—希尔排序

3.直接插入排序—采用顺序查找法查找插入位置

void lnsertSort(SqList &L) {
    int i, j
    for(i = 2; i<=L.length; ++i) {    // 若‘<’，需将L.[i】插入有序子表
        L.r[0] = L.r[i]             // 复制哨兵
        for(j = i-1;L.r[0];key<L.r[j].key;--j) {
            L.r[j+1] = L.r[j]      // 记录后裔
        }
        L.r[j+1] = L.r[0]    // 插入到正确的位置
    }
}

原始数据越接近有序序列，排序速度越快。元素移动的次数越小。

4.折半插入排序—查找位置时采用折半查找法。（已经排好序的）

void BInsertSort(SqList &L) {
    for(i =2;i<=L.length;++i) {    // 依次插入第2-第n个元素
        L.r[0] =L.r[i]             // 当前插入元素存到‘哨兵’位置
        low = 1; high = i-1        // 采用二分法查找法查找插入位置
        while(low <= high) {
            mid =(low+high)/2
            if(L.r[0].key < L.r[mid].key) high = mid -1
            else low = mid +1
        }    // 循环结束，high+1则为插入位置
        for(j = i-1;j>=high+1;--j) L.r[j+1] = L.r[j]    //向后移动元素
        L.r[high +1] = L.r[0]    // 插入到正确的位置
    }
}// BInsertSort

5.希尔排序—

思想：

先将整个待排记录序列分割成若干子序列，分别进行直接插入排序，待整个序列中的记录'基本有序'时，在对全体记录进行一次直接插入排序

特点：缩小增量，多遍插入排序

 理解：将数据分为多个间隔，每个间隔的相同位置进行比较排序，在不断缩小间隔，最后完成全部的排序。

 特点：

1.一次移动，移动位置较大，跳跃式的接近排序后的最终位置

2.最后一次只需要少量移动

3.增量序列必须是递减的，最后一个为1

4.增量序列应该都是质数的

void ShellSort(Sqlist &L;int dlta[],int t) {
    // 按照增量序列dlta[0,...t-1]对序列表L作哈希排序
    for(k = 0;k<t; ++k) {
        SheIIInser(L,dlta[k])        // 一趟增量为dlta[K]的插入排序
    }
}

void SheIIInser(SqList &L,int dk) {
    //  对顺序表L进行一趟增量为dk的shell排序，dk为步长因子
    for(i=dk+1;i<=L.length;++i)
        if(r[i].key < r[i-dk].key) {
            r[0] = r[i]
            for(j =i-dk; j>0 &&(r[0].key < r[j].key); j = j-dk) {
                r[j+dk] = r[j]
            }
            r[j+dk] = r[0]
        }
}

这篇关于算法之插入排序的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！