一、簡介

基數排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優先級排序。最后的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。基數排序基于分別排序，分別收集，所以是穩定的。

二、步驟

<1>.取得數組中的最大數，并取得位數； <2>.arr為原始數組，從最低位開始取每個位組成radix數組； <3>.對radix進行計數排序（利用計數排序適用于小范圍數的特點）；

三、示例

四、代碼實現

#define D 3                       /* D為排序碼的最大位數 */
#define R 10                      /* R為基數 */

typedef int KeyType;
typedef int DataType;

struct Node;                      /* 單鏈表結點類型 */
typedef struct Node RadixNode;

struct Node {
    KeyType key[D]; 
    /* DataType info;*/
    RadixNode *next;
};

typedef RadixNode * RadixList;

typedef struct QueueNode {
    RadixNode *f;                  /* 隊列的頭指針 */
    RadixNode *e;                  /* 隊列的尾指針 */
} Queue;

Queue queue[R];

void radixSort(RadixList * plist, int d, int r) {
    int i,j,k; 
    RadixNode *p, *head = (*plist)->next;

    for(j = d-1; j >= 0; j--) {         /* 進行d次分配和收集*/
        p = head;
        for(i = 0; i < r; i++) { 
            queue[i].f = NULL;  queue[i].e = NULL; /* 清隊列 */
        }

        while (p != NULL) {
            k = p->key[j];              /* 按排序碼的第j個分量進行分配*/
            if (queue[k].f == NULL) 
                queue[k].f = p;         /* 若第k個隊列為空，則當前記錄為隊頭*/ 
            else (queue[k].e)->next = p;/* 否則當前記錄鏈接到第k隊的隊尾*/
            queue[k].e = p;
            p = p->next;
        }

        for(i = 0; queue[i].f == NULL; i++) /* 找出第一個非空隊列*/
            ;
        p = queue[i].e;  head = queue[i].f; /* head為收集鏈表的頭指針*/

        for(i++; i < r; i++)
            if(queue[i].f != NULL) { /* 收集非空隊列 */
                p->next = queue[i].f;
                p = queue[i].e;
            }       
        p->next = NULL;
    }
    (*plist)->next = head;
}

struct Node element[11]={
    0,0,0,NULL,/*表頭*/
    0,3,6,NULL,/*36*/
    0,0,5,NULL,/*5*/
    0,1,6,NULL,/*16*/
    0,9,8,NULL,/*98*/
    0,9,5,NULL,/*95*/
    0,4,7,NULL,/*47*/
    0,3,2,NULL,/*32*/
    0,3,6,NULL,/*36*/
    0,4,8,NULL,/*48*/
    0,1,0,NULL /*10*/
};

int main(){
    int i;
    RadixList p = element;
    for (i = 0; i < 10; i++)
        element[i].next = &element[i+1];
    element[10].next = NULL;
    radixSort(&p, 3, 10);
    p = p->next;
    while (p != NULL){
        printf("%d ", p->key[1]*10+p->key[2]);
        p = p->next;
    }
    getchar();
    return 0;
}

五、評價

基數排序是穩定的。

六、參考資料

經典排序算法系列9----分配排序（桶排序和基數排序）
計數排序、基數排序和桶排序
十大經典算法總結(Javascript描述)