基数排序的原理是：假设所有要排序的数字位数为d位，不足的数字高位补0，从第一位开始，以该位为基准对数组进行排序（意思是将所有的数中的第1位提取出来，并按照大小进行排序，每一位所对应的数组元素也相应的改变次序），在排序好之后在选取第二位，以第二位为基准进行排序，一次类推，直到按照d位排序之后，数组的排序完成。

由于基数排序为稳定算法，所以在对每一位进行排序时，也应该选取稳定的排序算法进行排序。本代码中选取了算法时间复杂度并不是很好的排序算法——插入排序，但是该排序算法是稳定的。具体代码如下：
修改：此处的插入排序应该改为计数排序，插入排序时间复杂度太高。

  1. //基数排序，所选择的稳定的排序算法为计数排序。  

  2. #include<iostream>  

  3. using namespace std;  

  4. //使用插入排序作为稳定的排序算法时会导致算法时间复杂度超出线性时间。  

  5. void Insert_sort(int a[],int b[],int length)    

  6. {    

  7.     int i,j,key;    

  8.     for(i=1;i<length;i++)    

  9.     {    

  10.         key=b[i];    

  11.         j=i-1;    

  12.         while(key<b[j])    

  13.         {    

  14.             int temp;    

  15.             temp=a[j+1];    

  16.             a[j+1]=a[j];    

  17.             a[j]=temp;    

  18.    temp=b[j+1];    

  19.             b[j+1]=b[j];    

  20.             b[j]=temp;  

  21.             j=j-1;    

  22.             if(j<0)    

  23.             {    

  24.                 break;    

  25.             }    

  26.         }    

  27.     }    

  28. }    

  29. //使用计数排序法作为稳定的排序算法  

  30. //a为原始数组，divide为分割出来的第k位数字组成的数组  

  31. void CountSort(int a[],int divide[],int length)  

  32. {  

  33.  int c[100]={0},temp[100]={0};  

  34.  int i,j;  

  35.  //c[i]包含等于i的元素的个数  

  36.  for(j=0;j<length;j++)  

  37.  {  

  38.   c[divide[j]]+=1;  

  39.  }  

  40.  //c[i]包含小于等于i的元素的个数  

  41.  for(j=1;j<=9;j++)  

  42.  {  

  43.   c[j]+=c[j-1];  

  44.  }  

  45.  //将a[j]放到正确的位置  

  46.  for(j=length-1;j>=0;j--)  

  47.  {  

  48.   temp[c[divide[j]]]=a[j];  

  49.   c[divide[j]]-=1;  

  50.  }  

  51.  for(j=length-1;j>=0;j--)  

  52.  {  

  53.   a[j]=temp[j+1];  

  54.  }  

  55. }  

  56. //**********  

  57. //***********  

  58. //**********  

  59. void Divide(int a[],int b[],int d,int length)  

  60. {  

  61.  int i,j;  

  62.  int c[100]={0};  

  63.  for(i=0;i<length;i++)  

  64.  {  

  65.   c[i]=a[i];  

  66.  }  

  67.  for(i=0;i<length;i++)  

  68.  {  

  69.   for(j=1;j<d;j++)  

  70.   {  

  71.    c[i]/=10;  

  72.   }  

  73.   b[i]=c[i]%10;  

  74.  }  

  75. }  

  76. void RadixSort(int a[],int b[],int d,int length)  

  77. {  

  78.  int i;  

  79.  for(i=1;i<=d;i++)  

  80.  {  

  81.   Divide(a,b,i,length);  

  82.   CountSort(a,b,length);  

  83.  }  

  84. }  

  85. int main()  

  86. {  

  87.  int a[10],b[10];  

  88.  int i;  

  89.  for(i=0;i<10;i++)  

  90.  {  

  91.   a[i]=rand()%100000;  

  92.   cout<<a[i]<< ' ';  

  93.  }  

  94.  cout<<endl;  

  95.  RadixSort(a,b,5,10);  

  96.  for(i=0;i<10;i++)  

  97.  {  

  98.   cout<<a[i]<<' ';  

  99.  }  

  100.  cout<<endl;  

  101. }