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

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

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

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

    int array[SIZE] = {328, 4, 456, 656, 0, 1000, 439, 725, 328, 83,};

    RadixSort(array, SIZE, K);

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

    system("pause");
}

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