【数据结构】基数排序

内容描述

基数排序适合于有不同位数的大小数字，例如以下数列：

核心思想是：
先找十个桶：0~9
第一轮按照元素的个位数排序
桶内分别存放上述数组元素的个位数，按照数组元素的顺序依次存放

之后，按照从左向右，从上到下的顺序依次取出元素，组成新的数组。

在新的数组中，进行第二轮，按照十位数排序，依次存放于桶中：

按照之前的顺序取出，组成新的数组。
进行第三轮，按照百位数排序：

将百位数的元素取出之后，我们发现新的数组已经变成了有序数组

大家也已经发现，排序进行的轮数就是最大数的位数，这几轮进行之后，也就完成了基数排序。

全流程为此图：

代码实现

#include <iostream>
#define MAXNUM_KEY 8                //关键字项数的最大值 
#define RADIX 10                    //关键字基数，此时是十进制整数的基数 
#define MAX_SPACE 10000 
using namespace std;

typedef struct                       // 结点类型 
{ 
	char keys[MAXNUM_KEY];           //关键字 
  	int next;                       // 后继结点的下标 
}SLCell;
typedef struct
{ 
  	SLCell r[MAX_SPACE];                //静态链表的可利用空间，r[0]为头结点 
  	int keynum;                        //记录的当前关键字个数，即元素的最大长度 
  	int recnum;                       //静态链表的当前长度 
}SLList;                           //静态链表类型 

void InitList(SLList *L)
{ 
  	int i,n,keynum;     
  	cin>>n>>keynum;
  	(*L).keynum=keynum;
  	(*L).recnum=n;
  	for(i=1;i<=n;i++)
    	cin>>(*L).r[i].keys;
}

void Distribute(SLCell *r,int i,int *f,int *e)     // 分发函数(将元素按当前位的大小分组) 
{ 
  	int j,p; 
  	for(j=0;j<RADIX;++j)  f[j]=0; 
    for(p=r[0].next;p;p=r[p].next)
    { 
    	j=r[p].keys[i]-'0';                  // 当前位的大小 
    	if(!f[j])                            
    		f[j]=p;                        // 若为 0，则赋为该分组的头结点 
   		else  
    	    r[e[j]].next=p;              // 若头结点已有，则以尾插法插入 
    	e[j]=p;                         // e[j]用于记录该分组的尾结点，更新尾结点 
   	}
} 

void Collect (SLCell *r,int i,int *f,int *e)    // 集合函数，将分组后的每一组元素首尾相接 
{ 
  	int j,t;
  	for(j=0;!f[j];j++);                      // 找到第一组 
  	r[0].next=f[j];                         // r[0]为头结点 
  	t=e[j];                                // 记录当前分组的尾结点 
  	while(j<RADIX-1)
  	{ 
    	for(j++;j<RADIX-1&&!f[j];j++) ; // 找到下一组 
      	if(f[j]) 
      	{
       		r[t].next=f[j];          // 首尾相接 
       		t=e[j];                 // 更新尾结点 
      	}
  	} 
  	r[t].next=0;  
} 

void RadixSort(SLList &L)
{ 
   	int i;
   	int f[RADIX],e[RADIX];                     // f[RADIX]记录头结点,e[RADIX]记录尾结点 
   	for(i=0;i<L.recnum;++i)  L.r[i].next=i+1; // 下标初始化 
   	L.r[L.recnum].next = 0; 
   	for(i=L.keynum-1;i>=0;i--) 
   	{           
    	Distribute(L.r,i,f,e); 
     	Collect(L.r,i,f,e);    
   	}
}

void print(SLList L)
{  
  	int p,flag=1;
  	for(p=L.r[0].next;p;p=L.r[p].next)
  	{
	  	if(flag)
   		{cout<<L.r[p].keys;flag=0;}
   		else
    	cout<<" "<<L.r[p].keys;
   	}
}

int main()
{
  	SLList l;
  	InitList(&l);
  	RadixSort(l);
  	print(l);
  	return 0;
} 

参考：

八种排序算法之七：图解基数排序_Guo_ping’blog-CSDN博客_基数排序