基數排序 順序實現與鏈式實現

最近數據結構剛剛講完了基數排序，以下我的一些見解：

大多數的排序都是通過比較數據大小的方法對待排數據序列進行排序整理過程。

而基數排序卻很另類，那么，基數排序是采用怎樣的策略進行排序的呢？

簡要概括一下：基數排序是通過“分配”和“收集”兩個過程來實現排序的。

而這個思想該如何理解呢？請看以下例子：

（1）有以下待排序列

309 385 867 183 341 605 385

（2）第一次分配和收集：

首先按照各個數據的個位數字（即按照9，5，7，3，1，5，5）分配到0-9的10個區間內

結果如下：

分配結束后。接下來將所有空間中的數據按照序號由小到大依次重新收集起來，得到如下仍然無序的數據序列：

（3）第二次分配和收集：

 這次按照十位數字進行分配，步驟同上

結果如下：

分配結束后。接下來將所有空間中的數據按照序號由小到大依次再次收集起來，得到如下仍然無序的數據序列：

 

（4)第三次分配和收集：

 這次按照百位數字進行分配，步驟同上

結果如下：

分配結束后。接下來將所有空間中的數據按照序號由小到大依次再次收集起來；

哎？！停一下！奇怪，數據竟然有序了！

當然，數據分別按照個，十，百位依次排序后自然是有序的，至於為什么，我相信細心的讀者已經想明白了。

 

下面介紹一下對上面所說的基數排序算法做一些補充：

（1）如果數據大小更大，則需按照上面的思路繼續排序（比如排序到千位，萬位.....），排序的次數就是待排數據中最大數字的位數；

（2）上面的分析是說的數字的排序，如果要對等長的字符串集合排序，則各個空間的關鍵字由0-9變為‘a’-‘z’；

（3）基數排序是穩定的，而且看起來似乎在時間代價上很好，但實際並非如此，它在記錄數較關鍵字大得多的情況下比較有效，還有一個缺點是：它對一些數據類型來說是難於實現的，如對實型或不等長的字串。

下面再思考一個問題：既然我們可以從最低位到最高位進行如此的分配收集，那么是否可以由最高位到最低位依次操作呢？ 答案是完全可以的。

基於兩種不同的排序順序，我們將基數排序分為LSD（Least significant digital）或MSD（Most significant digital），

LSD的排序方式由數值的最右邊（低位）開始，而MSD則相反，由數值的最左邊（高位）開始。

注意一點：LSD的基數排序適用於位數少的數列，如果位數多的話，使用MSD的效率會比較好。

下面給出算法實現代碼：

鏈式實現：

#include <iostream>

using namespace std;
const int maxn=100000+10;
const int Radix=20;
typedef struct
{
    int next;
    int key;
}SLNode;
typedef struct
{
    SLNode r[maxn];
    int length;
}SLList;
typedef int ArrType[Radix];
ArrType f,e;
int Ord(int k,int j)
{
    for(int i=1;i<j;i++)
        k/=10;
    k%=10;
    return k+10;
}
void Print_L(SLList L)
{
    int mrk=0;
    for(int p=L.r[0].next;p;p=L.r[p].next)
    {
        if(mrk)
            printf(" ");
        printf("%d",L.r[p].key);
        mrk=1;
    }
    printf("\n");
}
void Distribute(SLList &L,int i,ArrType &f,ArrType &e)
{
    //printf("i=%d\n",i);
    for(int i=0;i<Radix;i++)
        f[i]=0;
    //for(int p=L.r[0].next;p!=0;p=L.r[p].next)
    for(int p=L.r[0].next;p;p=L.r[p].next)
    {
        int k=Ord(L.r[p].key,i);
        //printf("%d\n",k);
        if(f[k]==0)
        {
            f[k]=e[k]=p;
        }
        else
        {
            L.r[e[k]].next=p;
            e[k]=p;
        }
    }
}
void Collect(SLList &L,int i,ArrType &f,ArrType &e)
{
    int j=0;
    while(f[j]==0)
        j++;
    L.r[0].next=f[j];
    int tail=e[j];
    while(j<Radix)
    {
        j++;
        while(j<Radix&&f[j]==0)
            j++;
        L.r[tail].next=f[j];
        tail=e[j];
    }
}
void RadixSort(SLList &L)
{
    for(int i=1;i<=6;i++)//待排數據中最大值的位數，可根據實際需要變化
    {
        Distribute(L,i,f,e);
        Collect(L,i,f,e);
    }
}

int main()
{
    int n;
    scanf("%d",&n);
    SLList L;
    L.length=n;
    L.r[0].next=1;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&L.r[i].key);
        L.r[i].next=i+1;
    }
    L.r[n].next=0;
    RadixSort(L);
    Print_L(L);
    return 0;
}

鏈式時間復雜度： 

順序實現：

//庫函數頭文件包含
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>


//函數狀態碼定義
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE -1
#define OVERFLOW   -2
#define Radix      10
#define maxn       100010
typedef int  Status;
typedef int QElemType;

typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

Status InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q.front)
        exit(OVERFLOW);
    Q.front->next=NULL;
    return OK;
}
Status DestroyQueue(LinkQueue &Q)
{
    while(Q.front)
    {
        Q.rear=Q.front->next;
        free(Q.front);
        Q.front=Q.rear;
    }
    return OK;
}
Status EnQueue(LinkQueue &Q,QElemType e)
{
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p)
        exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}
Status DeQueue(LinkQueue &Q,QElemType &e)
{
    if(Q.front==Q.rear)
        return ERROR;
    QueuePtr p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)
        Q.rear=Q.front;
    free(p);
    return OK;
}
Status QueueEmpty(LinkQueue Q)
{
    if(Q.front==Q.rear)
        return TRUE;
    else
        return FALSE;
}
typedef struct
{
    int key;
}SLNode;
typedef struct
{
    SLNode r[maxn];
    int length;
}SLList;
LinkQueue B[Radix];
int Ord(int k,int j)
{
    for(int i=1;i<j;i++)
        k/=10;
    k%=10;
    return k;
}
void Print_L(SLList L)
{
    int mrk=0;
    for(int p=1;p<=L.length;p++)
    {
        if(mrk)
            printf(" ");
        printf("%d",L.r[p].key);
        mrk=1;
    }
    printf("\n");
}
void Distribute(SLList &L,int i)
{
    for(int j=1;j<=L.length;j++)
    {
        int k=Ord(L.r[j].key,i);
        EnQueue(B[k],L.r[j].key);
    }
}
void Collect(SLList &L)
{
    int i=1;
    for(int j=1;j<Radix;j++)
    {
        while(!QueueEmpty(B[j]))
            DeQueue(B[j],L.r[i++].key);
    }
}
void RadixSort(SLList &L)
{
    for(int i=0;i<Radix;i++)
    {
        InitQueue(B[i]);
    }
    for(int i=1;i<=6;i++)   //最高位數為6,可根據實際變化
    {
        Distribute(L,i);
        Collect(L);
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    SLList L;
    L.length=n;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&L.r[i].key);
    }
    RadixSort(L);
    Print_L(L);
    return 0;
}

順序時間復雜度：

 

（由於我們所用教材為嚴蔚敏老師編寫的，所以代碼風格接近，也易於讀懂。

 

堅持不懈地努力才能成為大神！