基数排序(RadixSort)

1 基数排序的特点是研究多个关键字key,且多个key之间有权重之分，

   或者可把单个key建模为含有多个key的排序

而计数排序、桶排序始终只有个一个key，或者说围绕着一个比较规则

Ex：比较年月日，先比较年份，如果相同，比较月份，如果还是相同，就比较日

2 根据首先选择有效位的不同，分为两种

A. 先比较最高有效位，然后在比较次高位的有效位，以此类推进行比较MSD(Most Significant Dight)

　    假如有189,321,312,167 需要考虑高有效位相同的情况与不同的情况

最高位不同：直接分出大小，并且需要记住312与321 > 比189,167大

最高位相同：比较十位，并且根据上述记录只比较312与321之间的十位数，否则排序是不稳定的

B. 先比较最低有效位，然后在比较次低位的有效位，以此类推进行比较LSD(Least Significant Dight)

无需考虑MSD排序遇到的问题，直接对每个位数排序即可

注意：每次排序只针对当前位数（辅助排序函数必须是基于稳定的）

3 可以使用基数排序对一些位数有限的十进制数排序(十进制整数每位固定大小0~9)

4 基数排序时间代价 O(d(n+k))(前提是辅助函数为计数排序的情况下)

d为关键值key的位数的个数，每位排序执行计数排序需要O(n+k)

 #include <iostream>
 #include <crtdbg.h>
 #include <cstring>
 using namespace std;

 const int SIZE = ;  //n的大小
 const int K = ;   //允许的最大整数
 enum numberBit
 {
     GeWei     = ,
     ShiWei    = ,
     BaiWei    = ,
     QianWei   = ,
 };
 //获取当前位数，d表示位数
 int GetData(const int data, int d)
 {
     int tmp = ;
     switch(d)
     {
     case GeWei:
         {
             tmp = data%;
         }
         break;
     case ShiWei:
         {
             tmp = data%;
             tmp = tmp/;
         }
         break;
     case BaiWei:
         {
             tmp = data%;
             tmp = tmp/;
         }
         break;
     case QianWei:
         {
             tmp = data/; //允许最大值为1000
         }
         break;
     default:
         {
             cout <<"wrong number, which big then k";
             return -;
         }
         break;
     }
     return tmp;
 }
 //计数排序, d为当前位数
 void CountingSort(int array[], int size, int d)
 {
     //建立辅助数组pCount大小固定为10(0~9)，用来存储统计的元素信息
     int *pCount = new int[];
     memset(pCount, , ()*sizeof(pCount[]));

     //建立辅助数组result存储结果
     int *result = new int[size];
     memset(result, , size*sizeof(result[]));

     //数组p使用元素大小做为下标，统计array的每个元素的个数
     for(int i=; i<; ++i)
     {
         int position = GetData(array[i], d);  //获取元素的位置
         pCount[position] = pCount[position] + ;
     }

     //数组p 记录每个元素x在数组array中 小于或等于x的个数
     //比如个位数时：小于等于4 的为元素 为3个（0， 1000， 83）
     for (int i=; i<=; ++i)
     {
         pCount[i] = pCount[i]+pCount[i-];
     }

     //根据上述获取的信息，进行排序
     //比如个位数时：小于等于4的为元素为3个（0， 1000， 83），4的位置为第4个
     for (int i=size-; i>=; --i)//此处为保证稳定性，从size-1 向 0 迭代
     {
         int data = GetData(array[i], d);
         int position = pCount[data];      //获取数组array[i]的位置
         result[position-] = array[i];    //放到正确的位置
         pCount[data]= pCount[data] - ;   //更新该元素的个数
     }
     //把结果存储到最初的数组array
     for (int i=; i<size; ++i)
     {
         array[i] = result[i];
     }
     delete [] pCount;
     delete [] result;
 }
 //基数排序，k为允许的最大整数
 void RadixSort(int array[], int size, int k)
 {
     //选择稳定排序即可，计数排序或者桶排序(桶排序具体实现请转到上一节)
     for (int i=; i<=k; i=i*) //i表示位数，从低有效位到高有效位 LSD
     {
         CountingSort(array, size, i);    //计数排序
     }
 }
 void main()
 {
     //检测是否有内存泄露 需要加头文件#include <crtdbg.h>
     _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

     int array[SIZE] = {, , , , , , , , , ,};

     RadixSort(array, SIZE, K);

     for (int i=; i<SIZE; ++i)
     {
         cout << array[i] << endl;
     }

     system("pause");
 }

（转载请注明作者和出处^_*  Seven++ http://www.cnblogs.com/sevenPP/  ）