桶排序升级之基数排序c语言实现10.1.2

上一篇介绍了不稳定的快速排序，这回介绍基数排序

基数排序是基于分配策略的排序，不是一种比较排序，不受到 O(n log n) 下限的影响，是一种稳定的排序算法，并且它可以应用于多关键字排序。

次位优先基数排序

先按照优先级别最低的位对序列进行排序，下一步按照稍高优先级的位对序列进行排序，直到最高位时候整个序列就是有序序列

主位优先基数排序

先按照优先级最高的位对序列进行排序，对序列中此位相同的元素按照稍低优先级位进行再排序（局部调整），最后得到的整个序列就是有序序列

说那么多不如直接分析代码来的实在

    /* 基数排序 - 次位优先 */         /* 假设元素最多有MaxDigit个关键字，基数全是同样的Radix */    #define MaxDigit 4    #define Radix 10         /* 桶元素结点 */    typedef struct Node *PtrToNode;    struct Node {        int key;        PtrToNode next;    };         /* 桶头结点 */    struct HeadNode {        PtrToNode head, tail;    };    typedef struct HeadNode Bucket[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 LSDRadixSort( ElementType A[], int N )    { /* 基数排序 - 次位优先 */         int D, Di, i;         Bucket B;         PtrToNode tmp, p, List = NULL;                    for (i=0; i<Radix; i++) /* 初始化每个桶为空链表 */             B[i].head = B[i].tail = NULL;         for (i=N-1; i>=0; i--) { /* 将原始序列按头插法存入初始链表List */             tmp = (PtrToNode)malloc(sizeof(struct Node));             tmp->key = A[i];             tmp->next = List;             List = tmp;         }         /* 下面开始排序 */          for (D=1; D<=MaxDigit; D++) { /* 对数据的每一位循环处理 */             /* 下面是分配的过程 */             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);         }     }

    /* 基数排序 - 主位优先 */         /* 假设元素最多有MaxDigit个关键字，基数全是同样的Radix */         #define MaxDigit 4    #define Radix 10         /* 桶元素结点 */    typedef struct Node *PtrToNode;    struct Node{        int key;        PtrToNode next;    };         /* 桶头结点 */    struct HeadNode {        PtrToNode head, tail;    };    typedef struct HeadNode Bucket[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位数进行排序 */         int Di, i, j;         Bucket B;         PtrToNode tmp, p, List = NULL;          if (D==0) return; /* 递归终止条件 */                   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->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);     }

时间效率^[1] ：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。