c语言基数排序

关于基数排序的原理可以参看浙江大学陈越的数据结构课程。以下是c语言实现的基数排序，包括LSD和MSD2种方式。

LSD

#include 
#include 
#include 

#define ElementType int
#define MaxDigit 4
#define Radix 10

/* 假设元素最多有MaxDigit个关键字，基数全是同样的Radix
关键字和基数
扑克牌排序，花色和点数是扑克牌的2种关键字
如果按先花色，再点数排序，则花色是主关键字，点数是次关键字
4种花色，13种点数，则是关键字对应的基数
在基数排序中，多关键字排序，可以对应为形式如abcd的序列，其中d是LSD,a是MSD
要点：
分配时，某个桶如果有多个元素，新元素插桶尾
合并为列表时，当前桶列表插在总列表的头部，原因是要保证序号小的桶的元素在前。
 */

/* 桶元素结点 */
typedef struct Node *PtrToNode;
struct Node
{
    int key;
    PtrToNode next;
};

/* 桶头结点 */
struct HeadNode
{
    PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];

ElementType *initA(int N);
void showA(ElementType A[], int N);
int getDigit(int X, int D);
void LSDRadixSort(ElementType A[], int N);

/*
LSD:Least significant digit
MSD:Most significant digit

 */

int main()
{
    srand(time(0));
    int N = 5;
    ElementType *A = initA(N);
    showA(A, N);
    LSDRadixSort(A, N);
    showA(A, N);

    return 0;
}

ElementType *initA(int N)
{
    int *A = (int *)malloc(N * sizeof(int));
    for (int i = 0; i < N; i++)
    {
        A[i] = rand() % 100;
        // A[i] = 1;
    }
    return A;
}

void showA(ElementType A[], int N)
{
    for (int i = 0; i < N; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
}

/* 基数排序 - 次位优先 */

int getDigit(int X, int D)
{ /* 默认次位D=1, 主位D<=MaxDigit */
    int d, i;

    for (i = 1; i <= D; i++)
    {
        d = X % Radix;
        X /= Radix;
    }
    return d;
}

void LSDRadixSort(ElementType A[], int N)
{ /* 基数排序 - 次位优先 */
    int D, Di, i;
    PtrToNode tmp, p, List = NULL;
    Bucket B;

    for (i = 0; i < Radix; i++) /* 初始化每个桶为空链表 */
        B[i].head = B[i].tail = NULL;
        
    for (i = 0; i < N; i++)
    { /* 将原始序列逆序存入初始链表List */
        tmp = (PtrToNode)malloc(sizeof(struct Node));
        tmp->key = A[i];
        tmp->next = List;
        List = tmp;
    }
    /* 下面开始排序 */
    for (D = 1; D <= MaxDigit; D++)
    { /* 对数据的每一位循环处理 */
        /* 下面是分配的过程
        分配，把每个数N,按当前位的值，分配到对应的桶中
        */
        p = List;
        while (p)
        {
            Di = getDigit(p->key, D); /* 获得当前元素的当前位数字 */
            /* 从List中摘除 */
            tmp = p;
            p = p->next;
            /* 插入B[Di]号桶尾 */
            tmp->next = NULL;
            if (B[Di].head == NULL)
                B[Di].head = B[Di].tail = tmp;
            else
            {
                B[Di].tail->next = tmp;
                B[Di].tail = tmp;
            }
        }
        /* 下面是收集的过程
        把桶中的当前轮次的结果，串成一个链表
         */
        List = NULL;
        for (Di = Radix - 1; Di >= 0; Di--)
        { /* 将每个桶的元素顺序收集入List */
            if (B[Di].head)
            { /* 如果桶不为空 */
                /* 整桶插入List表头 */
                B[Di].tail->next = List;
                List = B[Di].head;
                B[Di].head = B[Di].tail = NULL; /* 清空桶 */
            }
        }
    }
    /* 将List倒入A[]并释放空间 */
    for (i = 0; i < N; i++)
    {
        tmp = List;
        List = List->next;
        A[i] = tmp->key;
        free(tmp);
    }
}

MSD

#include 
#include 
#include 

#define ElementType int
#define MaxDigit 4
#define Radix 10

typedef struct LNode *List;
struct LNode
{
    int Data;
    List Next;
};

/* 桶元素结点 */
typedef struct Node *PtrToNode;
struct Node
{
    int key;
    PtrToNode next;
};

/* 桶头结点 */
struct HeadNode
{
    PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];

List FindKth(List L, int K);
List Insert(List L, int K, ElementType X);
void showList(List L);
List initList(int N);

ElementType *initA(int N);
void showA(ElementType A[], int N);

int getDigit(int X, int D);
void MSD(ElementType A[], int L, int R, int D);
void MSDRadixSort(ElementType A[], int N);

double run(int N, int num, int flag);

/*
性能：
7.47e-03
 */

int main()
{
    srand(time(0));
    int N = 10000;
    // ElementType *A = initA(N);
    // showA(A, N);
    // MSDRadixSort(A, N);
    // showA(A, N);
    int num = 100;
    int flag = 0;
    printf("%6.2e", run(N, num, flag));

    return 0;
}

ElementType *initA(int N)
{
    ElementType *A = (ElementType *)malloc(N * sizeof(ElementType));
    // ElementType B[] = {5, 4, 3, 2, 1};
    for (int i = 0; i < N; i++)
    {
        if (N < 20)
        {
            A[i] = rand() % 100;
            // A[i] = B[i];
        }
        else
        {
            A[i] = rand() % N; // 随机
            // A[i] = 1; // 全1
            // A[i] = i;//顺序
            // A[i] = N - 1 - i; // 逆序
        }
    }
    return A;
}

void showA(ElementType A[], int N)
{
    for (int i = 0; i < N; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
}

List FindKth(List L, int K)
{
    int loc = 1;
    List S = L;
    for (; S; S = S->Next)
    {
        if (K == loc)
        {
            break;
        }
        else
        {
            loc++;
        }
    }
    return S;
}

List Insert(List L, int K, ElementType X)
{
    List S, P;
    if (K == 1)
    {
        S = (List)malloc(sizeof(struct LNode));
        S->Next = L;
        S->Data = X;
        return S;
    }
    P = FindKth(L, K - 1);
    if (P != NULL)
    {
        S = (List)malloc(sizeof(struct LNode));
        S->Data = X;
        S->Next = P->Next;
        P->Next = S;
        return L;
    }
    else
    {
        printf("Error:Index %d out of range.\n", K);
        return NULL;
    }
}

void showList(List L)
{
    List S = L->Next;
    if (S)
    {
        for (; S; S = S->Next)
        {
            printf("%d ", S->Data);
        }
        printf("\n");
    }
}

List initList(int N)
{
    int i, K = 1;
    List L = NULL;

    for (i = 0; i < N; i++)
    {
        if (N < 100)
        {
            L = Insert(L, K, rand() % 100);
        }
        else
        {
            L = Insert(L, K, rand() % N);
            // L = Insert(L, K, 1);
            // L = Insert(L, K, i);
            // L = Insert(L, K, N-1-i);
        }
    }

    List H = (List)malloc(sizeof(struct LNode));
    H->Next = L;
    return H;
}

double run(int N, int num, int flag)
{
    clock_t start, stop;
    double duration, sum = 0.0;

    for (int i = 0; i < num; i++)
    {
        if (flag == 0)
        {

            int *A = initA(N);
            start = clock();
            MSDRadixSort(A, N);
            stop = clock();
        }
        else
        {
            List L = initList(N);
            start = clock();
            //
            stop = clock();
        }
        duration = ((double)(stop - start)) / CLK_TCK;
        sum += duration;
    }
    return sum / num;
}

/* 基数排序 - 主位优先 */

/* 假设元素最多有MaxDigit个关键字，基数全是同样的Radix */

int getDigit(int X, int D)
{ /* 默认次位D=1, 主位D<=MaxDigit */
    int d, i;

    for (i = 1; i <= D; i++)
    {
        d = X % Radix;
        X /= Radix;
    }
    return d;
}

void MSD(ElementType A[], int L, int R, int D)
{ /* 核心递归函数: 对A[L]...A[R]的第D位数进行排序 */
    if (D == 0)
        return; /* 递归终止条件 */

    int Di, i, j;
    PtrToNode tmp, p, List = NULL;
    Bucket B;

    for (i = 0; i < Radix; i++) /* 初始化每个桶为空链表 */
        B[i].head = B[i].tail = NULL;

    for (i = L; i <= R; i++)
    { /* 将原始序列逆序存入初始链表List */
        tmp = (PtrToNode)malloc(sizeof(struct Node));
        tmp->key = A[i];
        tmp->next = List;
        List = tmp;
    }

    /* 下面是分配的过程 */
    p = List;
    while (p)
    {
        Di = getDigit(p->key, D); /* 获得当前元素的当前位数字 */
        /* 从List中摘除 */
        tmp = p;
        p = p->next;
        /* 插入B[Di]号桶 */
        if (B[Di].head == NULL)
            B[Di].tail = tmp;
        // tmp被表头插入
        tmp->next = B[Di].head;
        B[Di].head = tmp;
    }
    /* 下面是收集的过程 */
    i = j = L; /* i, j记录当前要处理的A[]的左右端下标 */
    for (Di = 0; Di < Radix; Di++)
    { /* 对于每个桶 */
        if (B[Di].head)
        { /* 将非空的桶整桶倒入A[], 递归排序 */
            p = B[Di].head;
            while (p)
            {
                tmp = p;
                p = p->next;
                A[j++] = tmp->key;
                free(tmp);
            }
            /* 递归对该桶数据排序, 位数减1 */
            MSD(A, i, j - 1, D - 1);
            i = j; /* 为下一个桶对应的A[]左端 */
        }
    }
}

void MSDRadixSort(ElementType A[], int N)
{ /* 统一接口 */
    MSD(A, 0, N - 1, MaxDigit);
}