內部排序->基數排序->鏈式基數排序

文字描述

　　基數排序是和前面各類排序方法完全不相同，前面幾篇文章介紹的排序算法的實現主要是通過關鍵字間的比較和移動記錄這兩種操作，而實現基數排序不需要進行記錄關鍵字間的比較。基數排序是一種借助多關鍵字排序的思想對單邏輯關鍵字進行排序的方法。先介紹下什么是多關鍵字排序，以引入鏈式基數排序算法。

 

　　先介紹什么是多關鍵字排序：

　　比如，對撲克牌進行排序，每張撲克牌有兩個“關鍵字”：花色(梅花<方塊<紅桃<黑桃)和面值(2<3<,…,A)，且“花色”的地位高於”面值”， 那么對撲克牌排序有兩種方法：

　　方法1：先按不同“花色”分成有次序的4堆，每一堆的”花色”相同; 然后分別對每一堆內部按”面值”大小整理有序。這種先對主鍵字字進行排序，再對次關鍵字排序的方法叫最高位優先法(簡稱MSD: Most Significant first)

　　方法2：先按不同”面值”分成13堆，然后將13堆自小到大疊在一起(“3”在”2”之上，”4”在”3”之上,…,最上面的是4張”A”)，然后將這幅牌整個顛倒過來再重新按不同花色分成4堆，最后將這4堆按自小到的次序合在一起(梅花在最下面，黑桃在最上面)。這種先對次鍵字字進行排序，再對主關鍵字排序的方法叫最低位優先法(簡稱LSD: Least Significant first)

　　采用第二種方法LSD法對多關鍵字進行排序時，也可以不采用之前介紹的各種通過關鍵字間的比較來實現排序的方法，而是通過若干次“分配”和“收集”來實現排序。

 

　　關於鏈式基數排序的介紹：

　　采用多關鍵字排序中的LSD方法，先對低優先級關鍵字排序，再按照高點的優先級關鍵字排序，不過基數排序在排序過程中不需要經過關鍵字的比較，而是借助“分配”和“收集”兩種操作對單邏輯關鍵字進行排序的一種內部排序方法。

　　比如，若關鍵字是十進制表示的數字，且范圍在[0，999]內，則可以把每一個十進制數字看成由三個關鍵字組成(K0, K1, K2)，其中K0是百位數，K1是十位數，K2是個位數。基RADIX的取值為10； 按LSD進行排序，從最低位關鍵字起，按關鍵字的不同值將序列中記錄“分配”到RADIX個隊列中后再“收集”之，如此重復d次。按這種方法實現的排序稱之為基數排序，以鏈表作存儲結構的基數排序叫鏈式基數排序。

 

示意圖

 

算法分析

　　對n個記錄(假設每個記錄含d個關鍵字，每個關鍵字的取值范圍為rd個值)進行鏈式基數排序的時間復雜度為d*(n+rd)，其中每一躺分配的時間復雜度為n，每一躺收集的時間復雜度為rd，整個排序需進行d躺分配和收集。

　　所需輔助空間為2*rd個隊列指針，由於采用鏈表作存儲結構，相對於其他采用順序存儲結構的排序方法而言，還增加了n個指針域的空間。

　　鏈式基數排序是穩定的排序。

 

代碼實現

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DEBUG

#define EQ(a, b) ((a) == (b))
#define LT(a, b) ((a) <  (b))
#define LQ(a, b) ((a) <= (b))

//關鍵字項數的最大個數
#define MAX_NUM_OF_KEY    8
//關鍵字基數，此時是十進制整數的基數就是10
#define RADIX            10
//靜態鏈表的最大長度
#define MAX_SPACE        10000

//定義結點中的關鍵字類型為int
typedef int KeyType;
//定義結點中除關鍵字外的附件信息為char
typedef char InfoType;

//靜態鏈表的結點類型
typedef struct{
    //關鍵字
    KeyType    keys[MAX_NUM_OF_KEY];
    //除關鍵字外的其他數據項
    InfoType otheritems;
    int next;
}SLCell;

//靜態鏈表類型
typedef struct{
    //靜態鏈表的可利用空間，r[0]為頭結點
    SLCell r[MAX_SPACE];
    //每個記錄的關鍵字個數
    int keynum;
    //靜態鏈表的當前長度
    int recnum;
}SLList;

//指針數組類型
typedef int ArrType[RADIX];

void PrintSList(SLList L)
{
    int i = 0;
    printf("下標值 ");
    for(i=0; i<=L.recnum; i++){
        printf(" %-6d", i);
    }
    printf("\n關鍵字 ");
    for(i=0; i<=L.recnum; i++){
        printf(" %-1d%-1d%-1d,%-2c", L.r[i].keys[2], L.r[i].keys[1], L.r[i].keys[0], L.r[i].otheritems);
    }
//    printf("\n其他值 ");
//    for(i=0; i<=L.recnum; i++){
//        printf(" %-5c", L.r[i].otheritems);
//    }
    printf("\n下一項 ");
    for(i=0; i<=L.recnum; i++){
        printf(" %-6d", L.r[i].next);
    }
    printf("\n");
    return;
}

void PrintArr(ArrType arr, int size)
{
    int i = 0;
    for(i=0; i<size; i++){
        printf("[%d]%-2d ", i, arr[i]);
    }
    printf("\n");
}

/*
 *靜態鏈表L的r域中記錄已按(key[0],...,key[i-1])有序
 *本算法按第i個關鍵字keys[i]建立RADIX個子表，使同一子表中記錄的keys[i]相同。
 *f[0,...,RADIX-1]和e[0,...,RADIX-1]分別指向各子表中的第一個記錄和最后一個記錄。
 */
void Distribute(SLCell *r, int i, ArrType f, ArrType e)
{
    int j = 0;
    //各子表初始化為空
    for(j=0; j<RADIX; j++)
        f[j] = e[j] = 0;

    int p = 0;
    for(p=r[0].next; p; p=r[p].next){
        j = r[p].keys[i];
        if(!f[j])
            f[j] = p;
        else
            r[e[j]].next = p;
        //將p所指的結點插入第j個字表中
        e[j] = p;
    }
}

/*
 * 本算法按keys[i]自小到大地將f[0,...,RADIX-1]所指各子表依次鏈接成一個鏈表
 * e[0,...,RADIX-1]為各子表的尾指針
 */
void Collect(SLCell *r, int i, ArrType f, ArrType e){
    int j = 0, t = 0;
    //找到第一個非空子表，
    for(j=0; !f[j]; j++);
    //r[0].next指向第一個非空子表的第一個結點
    r[0].next = f[j];
    //t指向第一個非空子表的最后結點
    t = e[j];
    while(j<RADIX){
        //找下一個非空子表
        for(j+=1; !f[j]; j++);
        //鏈接兩個非空子表
        if(j<RADIX && f[j]){
            r[t].next = f[j];
            t = e[j];
        }
    }
    //t指向最后一個非空子表中的最后一個結點
    r[t].next = 0;
}

/*
 * L是采用靜態鏈表表示的順序表。
 * 對L作基數排序，使得L成為按關鍵字自小到大的有效靜態鏈表，L->r[0]為頭結點
 */
void RadixSort(SLList *L)
{
    int i = 0;
    //將L改造成靜態鏈表
    for(i=0; i<L->recnum; i++)
        L->r[i].next = i+1;
    L->r[L->recnum].next = 0;
#ifdef DEBUG
    printf("將L改造成靜態鏈表\n");
    PrintSList(*L);
#endif

    ArrType f, e;
    //按最低位優先依次對各關鍵字進行分配和收集
    for(i=0; i<L->keynum; i++){
        //第i趟分配
        Distribute(L->r, i, f, e);
#ifdef DEBUG
        printf("第%d趟分配---------------------------------------\n");
        PrintSList(*L);
        printf("頭指針隊列:");
        PrintArr(f, RADIX);
        printf("尾指針隊列:");
        PrintArr(e, RADIX);
#endif
        //第i躺收集
        Collect(L->r, i, f, e);
#ifdef DEBUG
        printf("第%d趟收集----\n");
        PrintSList(*L);
        printf("按next打印:");
        int p = 0;
        for(p=L->r[0].next; p; p=L->r[p].next){
            printf("%d%d%d ", L->r[p].keys[2], L->r[p].keys[1], L->r[p].keys[0]);
        }
        printf("\n");
#endif
    }
}

int getRedFromStr(char str[], int i, SLCell *result)
{
    int key = atoi(str);
    if(key<0 || key >999){
        printf("Error:too big!\n");
        return -1;
    }
    int units = 0, tens = 0, huns = 0;
    //百位
    huns = key/100;
    //十位
    tens = (key-100*huns)/10;
    //個位
    units = (key-100*huns-10*tens)/1;
    result->keys[0] = units;
    result->keys[1] = tens;
    result->keys[2] = huns;
    result->otheritems = 'a'+i-1;
    return 0;
}


int main(int argc, char *argv[])
{
    SLList L;
    int i = 0;
    for(i=1; i<argc; i++){
        if(i>MAX_SPACE)
            break;
        if(getRedFromStr(argv[i], i, &L.r[i]) < 0){
            printf("Error:only 0-999!\n");
            return -1;
        }
    }
    L.keynum = 3;
    L.recnum = i-1;
    L.r[0].next = 0;
    L.r[0].otheritems = '0';
    RadixSort(&L);
    return 0;
}

 

運行