数据结构——链式基数排序

#include <iostream>
using namespace std;

#define MAX_NUM_OF_KEY 8        //关键字项数的最大值
#define RADIX    10            //关键字基数，此时是十进制整数的基数
#define MAX_SPACE 10000
typedef int DataType ;
typedef struct
{
int data;        //数据，如571
DataType keys[MAX_NUM_OF_KEY];        //每个数据的所有关键字，571的5，7，1
int  next;
}SLCell;    //静态链表的节点类型

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

typedef int ArrType[RADIX];        //指针数组类型，声明两个指针数组，一个头指针，一个尾指针

////////////////////////////////////////////////////////////////////////////////
/*
ArrType    front[RADIX]                                                ArrType    end[RADIX]
|                                                |
f[0]        |------>[930]<----------------------------------|        e[0]
|                                                |
f[1]        |-->                                         <--|        e[1]
|                                                |
f[2]        |-->                                         <--|        e[2]
|                                                |
f[3]        |------>[063]-->[083]<--------------------------|        e[3]
|                                                |
f[4]        |------>[184]<----------------------------------|        e[4]
|                                                |
f[5]        |------>[505]<----------------------------------|        e[5]
|                                                |
f[6]        |-->                                         <--|        e[6]
|                                                |
f[7]        |-->                                         <--|        e[7]
|                                                |
f[8]        |------>[278]-->[008]<--------------------------|        e[8]
|                                                |
f[9]        |------>[109]-->[589]-->[269]<------------------|        e[9]

*/
//////////////////////////////////////////////////////////////////////////////////

void creatList(SLList &SLL)
{

int key, i=1,j;
cout<<"输入要进行排序的数据:"<<endl;
cin>>key;
while(key!=0)
{
SLL->R[i].data = key;
for(j = 1; j <= SLL->keynum; j++)
{
SLL->R[i].keys[j] = key % 10;
key /= 10;
}
SLL->R[i-1].next=i++;
cin>>key;
}
SLL->recnum = i-1;
SLL->R[SLL->recnum].next=0;
}

void print(SLList &SLL)
{
for(int p=SLL->R[0].next; p; p=SLL->R[p].next)
{
cout<<SLL->R[p].data<<"  ";
}
cout<<endl;
}

void distribute(SLCell *R, int i, ArrType front, ArrType end)
{
//静态链表L的R域中记录已按(keys[0]...keys[i-1]有序)。
//本算法按第i个关键字keys[i]建立RADIX个子表，使同一子表中记录的keys[i]相同。
//front[0...RADIX-1]和end[0...RADIX-1]分别指向各子表中第一个和最后一个记录。
for(int j=0; j<RADIX; ++j)
front[j] = 0;        //各子表初始化为空表
for(int p=R[0].next; p; p=R[p].next)
{
j=R[p].keys[i];            //映射第i个关键字
if(!front[j])
front[j] = p;        //若front[j]为空，则把记录连接到front[j]的头指针上
else
R[end[j]].next = p;    //若front[j]的头指针已经连接过了，说明已j为关键字的数据已经有了，
//这时把上一个以j为关键字的数据指向当前的这个数，即下标为p的数据
end[j] = p;        //尾指针重新指到每次更新的数据上
}
}//distribute

void collect(SLCell *R, int i, ArrType front, ArrType end)
{
//本算法按keys[i]自小到大地将f[0...RADIX-1]所指各子表依次链接成为一个链表
for(int j=0; !front[j]; j++)
;                    //找到第一个不为空的子表
R[0].next=front[j];            //重整静态链表
int k=end[j];                    //k为当前子表的尾指针
while(j<RADIX)
{
for(++j; j<RADIX; j++)
if(front[j])        //找下一个非空子表
{
R[k].next=front[j];        //连接
k=end[j];
}
}
R[k].next=0;                    //k指向最后一个非空子表的尾指针
}//collect

int main()
{
SLList SLL;
SLL=(SLList)malloc(MAX_SPACE*sizeof(Sllist));
SLL->R=(SLCell *)malloc(MAX_SPACE*sizeof(SLCell));
SLL->recnum=0;
SLL->keynum=3;

creatList(SLL);
cout<<"排序前:"<<endl;
print(SLL);

ArrType front,end;
for(int i = 1; i <= SLL->keynum; i++)    //按LSD法对各关键字进行分配和收集
{
distribute(SLL->R, i,front,end);    //第i趟分配
collect(SLL->R, i,front,end);        //第i趟收集
cout<<"第"<<i<<"分配和收集:"<<endl;
print(SLL);
}
return 0;
}