链式基数排序

/* c1.h (程序名) */
#include
#include
#include /* malloc()等 */
#include /* INT_MAX等 */
#include /* EOF(=^Z或F6),NULL */
#include /* atoi() */
#include /* eof() */
#include /* floor(),ceil(),abs() */
#include /* exit() */
/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
typedef int ElemType;


/* alg10-11.c 链式基数排序 */
typedef int InfoType; /* 定义其它数据项的类型 */
typedef int KeyType; /* 定义RedType类型的关键字为整型 */
typedef struct
{
	KeyType key; /* 关键字项 */
	InfoType otherinfo; /* 其它数据项 */
}RedType; /* 记录类型(同c10-1.h) */
typedef char KeysType; /* 定义关键字类型为字符型 */


#define MAX_NUM_OF_KEY 8 /* 关键字项数的最大值 */
#define RADIX 10 /* 关键字基数，此时是十进制整数的基数 */
#define MAX_SPACE 1000
typedef struct
{
	KeysType keys[MAX_NUM_OF_KEY]; /* 关键字 */
	InfoType otheritems; /* 其它数据项 */
	int next;
}SLCell; /* 静态链表的结点类型 */

typedef struct
{
	SLCell r[MAX_SPACE]; /* 静态链表的可利用空间，r[0]为头结点 */
	int keynum; /* 记录的当前关键字个数 */
	int recnum; /*  静态链表的当前长度 */
}SLList; /* 静态链表类型 */

typedef int ArrType[RADIX]; /* 指针数组类型 */

#include "linkRadix.h"
void InitList(SLList *L, RedType D[], int n)
{ /* 初始化静态链表L（把数组D中的数据存于L中） */
	char c[MAX_NUM_OF_KEY], c1[MAX_NUM_OF_KEY];
	int i, j, max = D[0].key; /* max为关键字的最大值 */
	for (i = 1; i= 0; j--)
			printf("%c", L.r[i].keys[j]);
		printf(" ");
		i = L.r[i].next;
	}
}

void RadixSort(SLList *L)
{ /* L是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字 */
	/* 自小到大的有序静态链表，L.r[0]为头结点。算法10.17 */
	int i;
	ArrType f, e;
	for (i = 0; i<(*L).recnum; ++i)
		(*L).r[i].next = i + 1;
	(*L).r[(*L).recnum].next = 0; /* 将L改造为静态链表 */
	for (i = 0; i<(*L).keynum; ++i)
	{ /* 按最低位优先依次对各关键字进行分配和收集 */
		Distribute((*L).r, i, f, e); /* 第i趟分配 */
		Collect((*L).r, f, e); /* 第i趟收集 */
		printf("第%d趟收集后:\n", i + 1);
		printl(*L);
		printf("\n");
	}
}

void print(SLList L)
{ /* 按数组序号输出静态链表 */
	int i, j;
	printf("keynum=%d recnum=%d\n", L.keynum, L.recnum);
	for (i = 1; i <= L.recnum; i++)
	{
		printf("keys=");
		for (j = L.keynum - 1; j >= 0; j--)
			printf("%c", L.r[i].keys[j]);
		printf(" otheritems=%d next=%d\n", L.r[i].otheritems, L.r[i].next);
	}
}

void Sort(SLList 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(SLList *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).recnum; ++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;
	}
}

#define N 10
void main()
{
	RedType d[N] = { { 278, 1 }, { 109, 2 }, { 63, 3 }, { 930, 4 }, { 589, 5 }, { 184, 6 }, { 505, 7 }, { 269, 8 }, { 8, 9 }, { 83, 10 } };
	SLList l;
	int *adr;
	InitList(&l, d, N);
	printf("排序前(next域还没赋值):\n");
	print(l);
	RadixSort(&l);
	printf("排序后(静态链表):\n");
	print(l);
	adr = (int*)malloc((l.recnum)*sizeof(int));
	Sort(l, adr);
	Rearrange(&l, adr);
	printf("排序后(重排记录):\n");
	print(l);
}