基数排序用例

原理

桶排序的推广，所谓的桶排序是将可能的取值作为桶，然后将数据放到桶里，最后将桶里的内容做个简单的收集就变成有序的数列了。基数排序继承这一思想，分为主位优先和次位优先。以扑克牌为例子！

主位优先

先按花色建立桶，然后对桶中的牌按面值进行排序，也就是只建一次桶。分治思想

次位优先

先以最次位关键字建立桶，按面值建立13个桶，分别有规则放进去，最后所有牌收集，再按花色建桶，然后再收集。最后序列，建两次桶。

代码

主位优先代码

#include<stdio.h>
#include<stdlib.h>
typedef int ElementType;
/* 基数排序 - 主位优先 */
 
/* 假设元素最多有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); 
}

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

int main()
{
	int a[10] = {64,8,216,512,27,729,0,1,343,125};
	MSDRadixSort(a,10);
	Print_Array(a,10);
	return 0;
}

次位位优先代码

//sort桶排序次位优先.c
#include<stdio.h>
#include<stdlib.h>
#define MaxDigist 4
#define Radix 10
typedef int ElementType;
typedef struct Node* PtrToNode;
struct Node {
	int key;
	struct Node* next;
};
struct HeadNode {
	PtrToNode head,tail;
};
typedef struct HeadNode Bucket[Radix];

int GetDigit(int X,int D)
{
	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=0;i<N;i++) {
		tmp = (PtrToNode)malloc(sizeof(struct Node));
		tmp->key = A[i];
		tmp->next = List;
		List = tmp;
	}
	
	//开始排序
	for(D=1;D<=MaxDigist;D++) {
		p = List;
		while(p) {
			Di = GetDigit(p->key,D);
			tmp = p;
			p = p->next;
			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--) {
			if(B[Di].head) {
				B[Di].tail->next = List;
				List = B[Di].head;
				B[Di].head = B[Di].tail = NULL;
 			}
		}
	}
	for(i=0;i<N;i++) {
		tmp = List;
		List = List->next;
		A[i] = tmp->key;
		free(tmp);
	}
}

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

int main()
{
	int a[10] = {64,8,216,512,27,729,0,1,343,125};
	LSDRadixSort(a,10);
	Print_Array(a,10);
	return 0;
}

总结

主位优先是分而治之，次位优先是按照分配收集，简单粗暴。所以一般情况次位优先更有效率