表插入排序（第十章 P267 算法10.3,10.18）

表插入排序

 

概述：

表插入排序，即使用链表的存储结构对数据进行插入排序。在对记录按照其关键字进行排序的过程中，不需要移动记录的存储位置，只需要更改结点间指针的指向。

 

排序过程：

在使用数组结构表示的链表中，设定数组下标为 0 的结点作为链表的表头结点，并令其关键字取最大整数。则表插入排序的具体实现过程是：首先将链表中数组下标为 1 的结点和表头结点构成一个循环链表，然后将后序的所有结点按照其存储的关键字的大小，依次插入到循环链表中。

将无序表{49，38，76，13，27}用表插入排序的方式进行排序。

• 首先使存储 49 的结点与表头结点构成一个初始的循环链表，完成对链表的初始化，如下表所示：

• 然后将以 38 为关键字的记录插入到循环链表中（只需要更改其链表的 next 指针即可），插入后的链表为：

• 再将以 76 为关键字的结点插入到循环链表中，插入后的链表为:

• 再将以 13 为关键字的结点插入到循环链表中，插入后的链表为：

• 最后将以 27 为关键字的结点插入到循环链表中，插入后的链表为：

• 最终形成的循环链表为：

 

 

 

对链表进行再加工

 

在表插入排序算法求得的有序表是用链表表示的，也就注定其只能进行顺序查找。而如果想用折半查找的算法，就需要对链表进行再加工，即对链表中的记录进行重新排列，具体做法为：遍历链表，将链表中第 i 个结点移动至数组的第 i 个下标位置中。

例如，上表是已经构建好的链表，对其进行再加工的过程为：

• 首先，通过其表头结点得知记录中关键字最小的是数组下标为 4 的关键字 13，而 13 应该放在数组下标为 1 的位置，所以需要同下标为 1 中存放的关键字进行调换。但是为了后期能够找到 49，将 13 的 next 域指向 49 所在的位置（改变之前需要保存原来的值，这里用 q 指针表示），如下表所示：

• 然后通过 q 指针找到原本 13 指向的下一位关键字 27，同时 q 指针指向下标为 2 的关键字 38，由于 27 应该移至下标为 2 的位置，所以同关键字 38 交换，同时改变关键字 27 的 next 域，如下表所示：

• 之后再通过 q 指针找到下一位关键字时，发现所指位置为下标 2，而之前已经经过了 2 次 移动，所以可以判定此时数组中存放的已经不是要找的，所以需要通过下标为 2 中的 next 域继续寻找，找到下标为 5 的位置，即关键字 38，由于下标 5 远远大于 2，可以判断 38 即为要找的值，所以同下标为 3 的记录交换位置，还要更改其 next 域，同时将 q 指针指向下标为 1 的位置，如下表所示：

• 然后通过 q 指针找到下一位关键字，由于其指向位置的下标 1 中的记录已经发生移动，所以通过 next 域找到关键字 49，发现它的位置不用改变；同样，当通过关键字 49 的 next 域找到下标为 3 的位置，还是需要通过其 next 域找到关键字 76 ，它的位置也不用改变。

 

 

算法性能：

从表插入排序的实现过程上分析，与直接插入排序相比只是避免了移动记录的过程（修改各记录结点中的指针域即可），而插入过程中同其它关键字的比较次数并没有改变，所以表插入排序算法的时间复杂度仍是O(n2)。

 

 

 

表结点类型：

 

 

静态链表类型：

 

 

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */


/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2 


/* -------------------------------     静态链表类型    --------------------------------*/

typedef int InfoType; /* 定义其它数据项的类型 */

#define SIZE 100 /* 静态链表容量 */
#define INT_MAX 999 
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; /* 静态链表类型 */

/* ------------------------------------------------------------------------------------------*/




/* -----------------------------    表插入排序    -------------------------------*/

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中记录按关键字 */
  /* 非递减有序顺序排列 算法10.3 */
	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，使其有序。算法10.18(L的类型有变) */
	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);
}


/* ------------------------------------------------------------------------------------------*/


 /* 检验以上操作的主程序 */

#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);
}

运行结果：