内部排序->插入排序->其它插入排序->表插入排序

文字描述

　　和之前的插入排序比，表插入排序可以保证排序过程中不移动记录；因此表插入排序所用的存储结构和之前的顺序存储不同，表插入排序采用静态链表类型作为待排记录序列的存储结构，设数组中下标0的分量为表头结点，并令表头结点记录的关键字取最大整数MAXINT。表插入排序的基本操作仍然是将一个记录插入到已经排好序的有序表中，和直接插入排序有相似之处，不同之处在于是以修改2次指针值代替1次移动记录。

示意图

算法分析

　　时间复杂度仍然是n*n， 因为排序过程中需要和数据个数相同的指针值，所以辅助空间为n，是稳定的排序方法。

代码实现

见附录1

---

　　另外, 与表插入排序相关的还有一个重排算法,  先依旧从文字描述, 示意图, 复杂度和代码实现四方面分析该算法.

文字描述

       表插入排序的结果只是求得一个有序链表,则只能对它进行顺序查找, 不能进行随机查找. 为了能实现有序表的折半查找,尚需对记录进行重新排列.

       重排记录的做法是: 顺序扫描有序链表, 将链表中第i个结点移动至数组的第i个分量重. 若第i个最小关键字的结点是数组中下标为p且p>i的分量,则互换SL.r[i]和SL.r[p]，且令SL.r[i]中指针域的值改为p； 由于此时数组中所有小于i的分量中已经是“到位”的分量，则当p<i时，应顺链继续查找直到p>i或p==i为止。

示意图

算法分析

在重排记录的过程中，最坏情况是每个记录到位都必须进行一次记录的交换，即3次移动记录，所以重排记录至多需进行3(n-1)次记录的移动， 它并不增加表插入排序的时间复杂度，还是n*n， 辅助空间为1

代码实现

见附录1

---

附录1

#include <stdio.h>
#include <stdlib.h>

#define DEBUG

//静态链表容量
#define SIZE 100
//最大整数
#define MAX  100

#define EQ(a, b) ((a) == (b))
#define LT(a, b) ((a) <  (b))
#define LQ(a, b) ((a) <= (b))

//定义关键字类型为整数类型
typedef int KeyType;
//定义其它数据项为整数类型
typedef int InfoType;

//记录类型
typedef struct{
    //关键字项
    KeyType key;
    //其他数据项
    InfoType otherinfo;
}RedType;    

//表结点类型
typedef struct{
    //记录项
    RedType rc;
    //指针项
    int next;
}SLNode;

//静态链表类型
typedef struct{
    //0号单元为表头结点
    SLNode r[SIZE];
    //链表当前长度
    int length;
}SLinkListType;

//顺序打印静态链表中的关键字和指向下个数据的指针
void PrintSList(SLinkListType SL){
    int i = 0;
    printf("下标值：");
    for(i=0; i<=SL.length; i++){
        printf("[%d]  ", i);
    }
    printf("
关键字：");
    for(i=0; i<=SL.length; i++){
        printf(" %-4d", SL.r[i].rc.key);
    }
    printf("
其他值：");
    for(i=0; i<=SL.length; i++){
        printf(" %-4c", SL.r[i].rc.otherinfo);
    }
    printf("

");
    return ;
}

//表插入排序算法
void TableInsertSort(SLinkListType *SL)
{
    //0号位表头结点，存最大整数值MAX
    SL->r[0].rc.key = MAX;
    //首先将静态链表中数组下标为1的分量和表头结点构成一个循环链表
    SL->r[0].next = 1;
    SL->r[1].next = 0;

    //和直接插入排序相似，只是不移动记录，只是改变指针指
    int i = 0, q = 0, p = 0;
    for(i=2; i<=SL->length; i++){
        q = 0;
        p = SL->r[q].next;
        while(LQ(SL->r[p].rc.key, SL->r[i].rc.key)){
            q = p;
            p = SL->r[q].next;
        }
        //以修改2次指针值代替移动记录
        SL->r[q].next = i;
        SL->r[i].next = p;
    }
    return ;
}

/*
 * 表插入排序相关的重排算法
 *
 * 根据静态链表SL中各结点的指针调整记录位置,
 * 使得SL中各记录按关键字升序排序
 *
 */
void Arrange(SLinkListType *SL)
{
    //p指示第一个记录的当前位置
    int p = SL->r[0].next, q = 0;
    int i = 0;
    SLNode tmp;

    //SL.r[1..i-1]中记录已按关键字有序排列
    for(i=1; i<SL->length; ++i){
        //第i个记录的在SL中的当前位置应不小于i
        while(p<i){
            p = SL->r[p].next;
        }
        //q指示尚未调整的表尾
        q = SL->r[p].next;
        if(p != i){
            //交换记录,使第i个记录到位
            tmp = SL->r[p];
            SL->r[p] = SL->r[i];
            SL->r[i] = tmp;
            //指向被移走的记录,使得以后可由while循环找回
            SL->r[i].next = p;
        }
        //p指示尚未调整的表尾,为找第i+1个记录作准备
        p = q;
#ifdef DEBUG
        printf("第%d趟重排:
", i);
        PrintSList(*SL);
#endif
    }
}

int main(int argc, char *argv[])
{
    if(argc < 2){
        return -1;
    }
    SLinkListType SL;
    int i = 0;
    for(i=1; i<argc; i++){
        if(i>SIZE)
            break;
        SL.r[i].rc.key = atoi(argv[i]);
        SL.r[i].next = 0;
        SL.r[i].rc.otherinfo = 'a'+i-1;
    }
    SL.length = (i-1);
    SL.r[0].rc.key = 0;
    SL.r[0].rc.otherinfo = '0';
    /*进行表插入排序*/
    TableInsertSort(&SL);
    printf("表插入排序之后的静态链表：
");
    PrintSList(SL);

    /*重排记录,使它能满足有序表的折半查找*/
    Arrange(&SL);
    return 0;
}

运行