【笔记】表插入排序

  插入排序：将待排序元素分为已排序子集和未排序子集，一次从未排序子集中的一个元素插入已排序子集中，使已排序自己仍然有序；重复执行以上过程，指导所有元素都有序为止。

 #define SIZE 100 /* 静态链表容量 */
 typedef int KeyType; /* 定义关键字类型为整型 */

 typedef struct
 {
   KeyType key; /* 关键字项 */
   InfoType otherinfo; /* 其它数据项，具体类型在主程中定义 */
 }RedType; /* 记录类型 */

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

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

  基本算法思想：假设以上述说明的静态链表类型作为待排记录序列的存储结构，并且为了插入方便起见，设数组中下标为0的分量为表头结点，并令表头结点记录的关键字取最大整数MAXINT。则表插入排序的过程描述如下：首先将静态链表中数组下标为1的分量和表头结点构成一个循环链表，然后依次将下标为2至n的分量（结点）按记录关键字非递减有序插入到循环链表中。

  以序列（49，38，65，97，76，13，27，49）为例，表插入排序的过程如下图所示。

  从表插入排序的过程可见，表插入排序的基本操作仍是将一个记录插入到已排好序的有序表中。和直接插入排序相比，不同之处仅是修改2n次指针值代替移动记录，排序过程中所需进行的关键字间的比较次数相同。因此表插入排序的时间复杂度仍是$O(n^2)$。

  表插入排序的结果只是求得一个有序链表，则只能对它进行顺序查找，不能进行随机查找，为了能实现有序表的折半查找，尚需对记录进行重新排列。
  重排记录的做法：顺序扫描有序链表，将链表中的第i个结点移动至数组的第i个分量中。如下图所示，（a）是经表插入排序后得到的有序链表SL。根据头结点中指针域的指示，链表的第一个结点，即关键字最小的结点是数组中下标为6的分量，其中记录应移动至数组的第一个分量中，则将SL.r[1]和SL.r[6]互换，并且为了不中断静态链表中的链，即在继续顺链扫描时仍能找到互换之前在SL.r[1]中的结点，令互换之后的SL.r[1]中指针域的值修改为6。推广至一般情况，若第i个最小关键字的结点是数组中下标为$p$且$p >i$的分量，则互换SL.r[i]和SL.r[p]，且令SL.r[i]中指针域的值改为p；由于此时数组中所有小于i的分量中已是“到位”的记录，则当$p <i$时，应顺链继续查找直到$p \geq i$为止。

• 头文件

 #define MAXSIZE 20 /* 一个用作示例的小顺序表的最大长度 */
 typedef int InfoType; /* 定义其它数据项的类型 */
 typedef int KeyType; /* 定义关键字类型为整型 */
 typedef struct
 {
   KeyType key; /* 关键字项 */
   InfoType otherinfo; /* 其它数据项，具体类型在主程中定义 */
 }RedType; /* 记录类型 */

 typedef struct
 {
   RedType r[MAXSIZE+1]; /* r[0]闲置或用作哨兵单元 */
   int length; /* 顺序表长度 */
 }SqList; /* 顺序表类型 */

• 函数文件

 void TableInsert(SLinkListType *SL,RedType D[],int n)
 { /* 由数组D建立n个元素的表插入排序的静态链表SL */
   int i,p,q;
   (*SL).r[0].rc.key=INT_MAX; /* 表头结点记录的关键字取最大整数(非降序链表的表尾) */
   (*SL).r[0].next=0; /* next域为0表示表尾(现为空表，初始化) */
   for(i=0;i<n;i++)
   {
     (*SL).r[i+1].rc=D[i]; /* 将数组D的值赋给静态链表SL */
     q=0;
     p=(*SL).r[0].next;
     while((*SL).r[p].rc.key<=(*SL).r[i+1].rc.key)
     { /* 静态链表向后移 */
       q=p;
       p=(*SL).r[p].next;
     }
     (*SL).r[i+1].next=p; /* 将当前记录插入静态链表 */
     (*SL).r[q].next=i+1;
   }
   (*SL).length=n;
 }

 void Arrange(SLinkListType *SL)
 { /* 根据静态链表SL中各结点的指针值调整记录位置，使得SL中记录按关键字 */
   /* 非递减有序顺序排列  */
   int i,p,q;
   SLNode t;
   p=(*SL).r[0].next; /* p指示第一个记录的当前位置 */
   for(i=1;i<(*SL).length;++i)
   { /* (*SL).r[1..i-1]中记录已按关键字有序排列,第i个记录在SL中的当前位置应不小于i */
     while(p<i)
       p=(*SL).r[p].next; /* 找到第i个记录，并用p指示其在SL中当前位置 */
     q=(*SL).r[p].next; /* q指示尚未调整的表尾 */
     if(p!=i)
     {
       t=(*SL).r[p]; /* 交换记录，使第i个记录到位 */
       (*SL).r[p]=(*SL).r[i];
       (*SL).r[i]=t;
       (*SL).r[i].next=p; /* 指向被移走的记录，使得以后可由while循环找回 */
     }
     p=q; /* p指示尚未调整的表尾，为找第i+1个记录作准备 */
   }
 }

 void Sort(SLinkListType L,int adr[])
 { /* 求得adr[1..L.length]，adr[i]为静态链表L的第i个最小记录的序号 */
   int i=1,p=L.r[0].next;
   while(p)
   {
     adr[i++]=p;
     p=L.r[p].next;
   }
 }

 void Rearrange(SLinkListType *L,int adr[])
 { /* adr给出静态链表L的有序次序，即L.r[adr[i]]是第i小的记录。 */
   /* 按adr重排L.r，使其有序. */
   int i,j,k;
   for(i=1;i<(*L).length;++i)
     if(adr[i]!=i)
     {
       j=i;
       (*L).r[0]=(*L).r[i]; /* 暂存记录(*L).r[i] */
       while(adr[j]!=i)
       { /* 调整(*L).r[adr[j]]的记录到位直到adr[j]=i为止 */
         k=adr[j];
         (*L).r[j]=(*L).r[k];
         adr[j]=j;
         j=k; /* 记录按序到位 */
       }
       (*L).r[j]=(*L).r[0];
       adr[j]=j;
     }
 }

 void print(SLinkListType L)
 {
   int i;
   for(i=1;i<=L.length;i++)
     printf("key=%d ord=%d next=%d\n",L.r[i].rc.key,L.r[i].rc.otherinfo,L.r[i].next);
 }

• 主程序

 #include<limits.h>
 #define N 8
 void main()
 {
   RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};
   SLinkListType l1,l2;
   int *adr,i;
   TableInsert(&l1,d,N);
   l2=l1; /* 复制静态链表l2与l1相同 */
   printf("排序前:\n");
   print(l1);
   Arrange(&l1);
   printf("l1排序后:\n");
   print(l1);
   adr=(int*)malloc((l2.length+1)*sizeof(int));
   Sort(l2,adr);
   for(i=1;i<=l2.length;i++)
     printf("adr[%d]=%d ",i,adr[i]);
   printf("\n");
   Rearrange(&l2,adr);
   printf("l2排序后:\n");
   print(l2);
 }

• 测试结果