基数排序

介绍：

　　(radix sort）则是属于“分配式排序”（distribution sort），基数排序法又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。

解法：

　　基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

示例：　　

   以LSD为例，假设原来有一串数值如下所示：

　　73, 22, 93, 43, 55, 14, 28, 65, 39, 81

　　1：首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：

　　0

　　1 81

　　2 22

　　3 73 93 43

　　4 14

　　5 55 65

　　6

　　7

　　8 28

　　9 39

　　接下来将这些桶子中的数值重新串接起来，成为以下的数列：

　　81, 22, 73, 93, 43, 14, 55, 65, 28, 39

　　2：接着再进行一次分配，这次是根据十位数来分配：

　　0

　　1 14

　　2 22 28

　　3 39

　　4 43

　　5 55

　　6 65

　　7 73

　　8 81

　　9 93

　　接下来将这些桶子中的数值重新串接起来，成为以下的数列：

　　14, 22, 28, 39, 43, 55, 65, 73, 81, 93

　　这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。

　　LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好，MSD的方 式恰与LSD相反，是由高位数为基底开始进行分配，其他的演算方式则都相同。

 

效率分析

　　时间效率：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的 时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。

实现方法

　　最高位优先(Most Significant Digit first)法，简称MSD法：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分 组，直到按最次位关键码kd对各子组排序后。再将各组连接起来，便得到一个有序序列。

　　最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。

代码实现：

JAVA实现代码：

　　public class RadixSort
 {

　　public static void sort(int[] number, int d) {//注意参数

　　int k=0;

　　int n=1;

　　int m=1;

　　int[][] temp = new int[number.length][number.length];

　　int[] order = new int[number.length];

　　while(m <= d) {

　　for(int i = 0; i < number.length; i++) {

　　int lsd = ((number[i] / n) % 10);

　　temp[lsd][order[lsd]] = number[i];

　　order[lsd]++;

　　}

　　for(int i = 0; i < d; i++)
 {

　　  if(order[i] != 0)

　  　for(int j = 0; j < order[i]; j++) 
     {

　   　number[k] = temp[i][j];

　　   k++;
   
　　}

　　order[i] = 0;

　　}

　   　n *= 10;

　　   k = 0;

　   　m++;

　　}

　　}

　　public static void main(String[] args)
 {
     //初始化数组：
　　int[] data ={73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100};

　　RadixSort.sort(data, 10);//函数调用

　　for(int i = 0; i < data.length; i++)
       {

　　         System.out.print(data[i] + " ");

　　    }
　　}

习题拓展：

任务：

假设有n个待排序记录，记录R_i的关键字为Key_i, Key_i由d位十进制数字组成，即Key_i=K_i¹ K_i² K_i³ … K_i^d ,试分别采用链式存储结构和顺序存储结构实现基数排序。

实现代码：

顺序存储：

//___________________________________顺序存储________________________________________________________
# include <iostream.h>
# include <stdio.h>
# include <conio.h>
# define MAX_NUM_OF_KEY 8//关键字项数的最大值
# define RD 10//关键字基数，此时是十进制整数的基数
# define MAX_SPACE 10000
# define ERROR -1

typedef int KeyType;//关键字类型
typedef int InfoType;//数据域类型
typedef int ArrType[RD];//指针数组类型，存放10个队列

typedef struct SLCell//记录，静态链表的节点类型
{
 KeyType keys[MAX_NUM_OF_KEY];//关键字
    InfoType otheritmes;//其他数据项
 int next;
}SLCell;

typedef struct SLList //存放记录的线性表
{
 SLCell r[MAX_SPACE];//静态链表可利用的空间，r[0]为头结点
    int keynum;//记录的当前关键字个数
    int recnum;//静态链表的当前长度
}SLList;
//keys(L.r[i].keys[],L.r[i].otheritmes) ;
void  keys(int keys[] ,int n)//为关键字赋值,关键字是从个位到高位一次放入数组Key[]的
{
 int i;
 for(i=0;n>0;i++)
 {
        keys[i]=n;
  n=n/10;
 }
 
}
void OutExample(SLList L,int i)
{
 int p;
 cout<<endl;
 cout<<"第"<<i+1<<"趟搜集结果是：";
 for(p=L.r[0].next;L.r[p].next;p=L.r[p].next)
 {
  cout<<L.r[p].otheritmes<<"->";
 }
 cout<<L.r[p].otheritmes<<endl;

}

void creatExample(SLList &L)
{
 int i,j;
 //char a[MAX_NUM_OF_KEY];
 cout<<"请输入待排序记录的个数："<<endl;
 cin>>L.recnum;
 cout<<"请输入关键字个数："<<endl;
 cin>>L.keynum;
 for(i=1;i<=L.recnum;i++)//给关键字初始化为0
 {
  for(j=0;j<L.recnum;j++)
   L.r[i].keys[j]=0;
 }
 cout<<"请输入待排序记录："<<endl;
 for(i=1;i<=L.recnum;i++)//输入数据项
 {  
  
  cin>>L.r[i].otheritmes;
  keys(L.r[i].keys,L.r[i].otheritmes) ;//为关键字赋值,关键字是从个位到高位一次放入数组Key[]的
  
 }
 cout<<endl<<"表L为:"<<endl;
 for(i=1;i<L.recnum;i++)//输出据项
  cout<<L.r[i].otheritmes<<"->";
 cout<<L.r[i].otheritmes<<endl;
 for(i=0;i<L.recnum;i++)//给next赋值
        L.r[i].next=i+1;
 L.r[L.recnum].next=0;
}


void Distribute(SLList & L,int i,ArrType &f,ArrType &e)//第i趟分配,按第i个关键字搜集
{
 int j,p;
    for(j=0;j<RD;j++)//队头指针初始化
    f[j]=0;//各子表初始化为空表
 for(p=L.r[0].next;p;p=L.r[p].next)//p指示当前节点位置
 { 
  j=L.r[p].keys[i];
        if(f[j]==0)//若该子表为空
   f[j]=p;
  else//若该子表不空
   L.r[e[j]].next=p;//将p指向的节点插入第个i子表中
  e[j]=p;//表尾指针指向该节点
 }
}

void Collect(SLList &L,int i,ArrType f,ArrType e)//第i趟收集
{
 int j,t;                       
 for(j=0;!f[j];j++);//找到第一个非空子表
 L.r[0].next=f[j];//r[0].next指向第一个非空子表的第一个节点
 t=e[j];//用t记录当前子表的最后一个节点
 while(j<RD-1)
 {
  for(j=j+1;j<RD-1&&!f[j] ;j++);//找下一个非空子表
  if(f[j])
  {
   L.r[t].next=f[j];
   t=e[j];//用t记录当前子表的最后一个节点
  }
 }
 L.r[t].next=0;//t指向最后一个非空子表的最后一个节点
 OutExample(L,i);
}

void RadixSort(SLList &L)//基数排序
{
 int i;
    ArrType f,e;//队头指针，队尾                                                                                                                                                                                                                                                       
 for(i=0;i<L.keynum;i++)//进行keynum趟分配，收集
 {
  Distribute(L,i,f,e);//第i趟分配
  Collect(L,i,f,e);//第i趟分收集
 }
}
void main()
{
 SLList L;
    cout<<"基数排序(顺序存储).cpp"<<endl<<"============="<<endl<<endl;
 creatExample(L);
 RadixSort(L);
}

 

链式存储：

链式存储：

//___________________________________链式存储________________________________________________________
# include <iostream.h>
# include <stdio.h>
# include <conio.h>
#include<malloc.h>
# define MAX_NUM_OF_KEY 8//关键字项数的最大值
# define RD 10//关键字基数，此时是十进制整数的基数
# define MAX_SPACE 10000
# define ERROR -1

typedef int KeyType;//关键字类型
typedef int InfoType;//数据域类型


typedef struct SLCell//结点
{
 KeyType keys[MAX_NUM_OF_KEY];//关键字
    InfoType otheritmes;//其他数据项
 struct SLCell * next;
}SLCell,* LNode;
typedef LNode ArrType[RD];//指针数组类型，存放10个队列

typedef struct SLList //存放记录的线性表
{
 SLCell *H;// L 为单链表的头指针
    int keynum;//记录的当前关键字个数
    int recnum;//静态链表的当前长度
}SLList;
//keys(L.r[i].keys[],L.r[i].otheritmes) ;
void  keys(int keys[] ,int n)//为关键字赋值,关键字是从个位到高位一次放入数组Key[]的
{
 int i;
 for(i=0;n>0;i++)
 {
        keys[i]=n;
  n=n/10;
 }
 
}
void OutExample(SLList L,int i)
{
 SLCell * p;
 cout<<endl;
 cout<<"第"<<i+1<<"趟搜集结果是：";
 for(p=L.H->next;p->next;p=p->next)
 {
  cout<<p->otheritmes<<"->";
 }
 cout<<p->otheritmes<<endl;

}

void creatExample(SLList &L)//尾插法建立链表
{
 int i,j,n;
 SLCell *p,*q;//q指向表尾
 cout<<"请输入待排序记录的个数："<<endl;
 cin>>L.recnum;
 cout<<"请输入关键字个数："<<endl;
 cin>>L.keynum;
 L.H=(SLCell *)malloc(sizeof(SLCell));//头结点，尾插法建立链表
 L.H->next=NULL;
 q=L.H;
 cout<<"请输入待排序记录："<<endl;
 for(i=1;i<=L.recnum;i++)//输入数据项
 {  
  cin>>n;
  p=(SLCell *)malloc(sizeof(SLCell));
  p->otheritmes=n;
  for(j=0;j<L.recnum;j++)//给关键字初始化为0
   p->keys[j]=0;
  p->next=NULL;
  q->next=p;
  q=p;
 }
 p=L.H->next;
 while(p!=NULL)
 {
  keys(p->keys,p->otheritmes) ;//为关键字赋值,关键字是从个位到高位一次放入数组Key[]的
  p=p->next;
 }
 cout<<endl<<"表L为:"<<endl;
 for(i=1,p=L.H->next;i<L.recnum;i++)//输出据项
 {
  cout<<p->otheritmes<<"->";
  p=p->next;
 }
 cout<<p->otheritmes;
}


void Distribute(SLList & L,int i,ArrType &f,ArrType &e)//第i趟分配,按第i个关键字搜集
{
 int j;
 SLCell *p;
    for(j=0;j<RD;j++)//队头指针初始化
    f[j]=NULL;//各子表初始化为空表
 for(p=L.H->next;p;p=p->next)//p指示当前节点位置
 { 
  j=p->keys[i];
        if(f[j]==NULL)//若该子表为空
   f[j]=p;
  else//若该子表不空
   e[j]->next=p;//将p指向的节点插入第个i子表中
  e[j]=p;//表尾指针指向该节点
 }
}

void Collect(SLList &L,int i,ArrType f,ArrType e)//第i趟收集
{
 int j;
 SLCell *t;
 for(j=0;!f[j];j++);//找到第一个非空子表
 L.H->next=f[j];//r[0].next指向第一个非空子表的第一个节点
 t=e[j];//用t记录当前子表的最后一个节点
 while(j<RD-1)
 {
  for(j=j+1;j<RD-1&&!f[j] ;j++);//找下一个非空子表
  if(f[j])
  {
   t->next=f[j];
   t=e[j];//用t记录当前子表的最后一个节点
  }
 }
 t->next=NULL;//t指向最后一个非空子表的最后一个节点
 OutExample(L,i);
}

void RadixSort(SLList &L)//基数排序
{
 int i;
    ArrType f,e;//队头指针，队尾                                                                                                                                                                                                                                                       
 for(i=0;i<L.keynum;i++)//进行keynum趟分配，收集
 {
  Distribute(L,i,f,e);//第i趟分配
  Collect(L,i,f,e);//第i趟分收集
 }
}
void main()
{
 SLList L;
    cout<<"基数排序(链式存储).cpp"<<endl<<"============="<<endl<<endl;
 creatExample(L);
 RadixSort(L);
}

有关更多基数排序请参考：

http://baike.baidu.com/link?url=sxtehOE8g8X-jPRJD-FB3ywN5Aik-InMB6EzeUGM94k2ny3r5BJqD-3sWOv5QkZFRTQYD4kYNKlPbSmY69O8J