基数排序的数组/链表实现

/************************************************************
*基数排序
*使用数组/链表完成
*核心代码： radixSortByArr(int arr[], int n) / radixSortByList(int arr[], int n)
*使用数组实现的算法核心： res[ arr[i] ]+=1 ; //将待排序数组的值当作索引计数（res[20]=2;表示有2个20）
*使用链表实现的算法核心： 循环MaxBit次。从低位到高位，每次排序一位。
                          使用链表记录每次的排序结果，采用尾查法实现链表内部的排序
                          一趟排序结束，将结果输出到待排序数组中
*author: fangchang
*date:   2016/03/25
*time:   11：34
**************************************************************/


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


#define N 5                        //待排序数的个数
#define RADIX_NUM 10               //桶的个数，0-9共10个数字，所以是10    


typedef struct node {              //链表的节点声明
int value;
struct node *next;
}*pnode;


void deleteList(pnode head);                 //清空链表
void insertInEnd(pnode head,int value);      //尾插
void answer1();
void radixSortByArr(int arr[], int n);      //使用数组实现基数排序（所有的数字都是正整数）


void answer2();
void radixSortByList(int arr[], int n);      //core code 
void printToArr(pnode radixArr[],int arr[], int n);
int findMax(int arr[] , int n);              //数组中的最大值
int maxBitNum(int value);                    //最大值的位数（111的位数是3）
int valueInBit(int value, int bitNum);       //返回指定位(bitNum)上的数字(0-9)
int main() {
//answer1();
answer2();
fflush(stdin);
getchar();
return 1;
}


void answer1(){                                 //使用数组完成基数排序
int arr[N]={1,2,2,11,3};
radixSortByArr(arr,N);
}
void radixSortByArr(int arr[], int n) {        //基数排序(数据结构： 数组)
int i;
int max=0;
int *res;
int len;
for(i=0;i<n;++i) {
if(max<arr[i]) {
max=arr[i];
}
}
len=max+1;
res = (int *) malloc(sizeof(int)*(max+1));
if(!res) {
return;
}
memset(res,0,len*sizeof(int));
for(i=0;i<n;++i) {
res[ arr[i] ]+=1;                  //core code
}
for(i=1;i<=len;++i) {
for(res[i];res[i]>0;--res[i]) {
printf("%d  ",i);
}
}
printf("\n");
} 


void answer2() {                                //使用10个链表完成基数排序 
int arr[N]={111111,232,2,11,3};
radixSortByList(arr,N);
}
void radixSortByList(int arr[], int n) {         //基数排序(数据结构： 链表)  
int loopNum = maxBitNum(findMax(arr,n));
pnode radixArr[RADIX_NUM] ;                               //保存10个链表，radixArr[0]保存相应位为0的数
int i,j,tmp;
pnode p;
for(i=0;i<RADIX_NUM;++i) {                                //初始化10个链表头结点
p = (pnode) malloc(sizeof(struct node));
if(!p) {
printf("radixSortByList malloc has error!\n");
return ;
}
p->value=0;
p->next=NULL;
radixArr[i] = p ;
}
for(i=0;i<loopNum;++i) {                       //最多有loopNum位，则循环loopNum次
for(j=0;j<n;++j) {                         //遍历待排序数字
tmp = valueInBit(arr[j],i+1);          //得到每个数字相应位上的数
insertInEnd(radixArr[tmp],arr[j]);     //插入到相应的链表中
}                                          //一趟排序
printToArr(radixArr,arr,n);                //更新待排序数组（将排序结果存入数组中）
for(j=0;j<RADIX_NUM;++j) {                 //删除桶中数据，即清空链表数组
p=radixArr[j]->next;
radixArr[j]->next=NULL;
deleteList(p);
}
}
for(i=0;i<n;++i) {                            //打印最终排序结果
printf("%d  ",arr[i]);
}
printf("\n");
}




void printToArr(pnode radixArr[],int arr[], int n) {             //更新待排序数组（将排序结果存入数组中）
int i;
int j=0;
pnode p;
for(i=0;i<RADIX_NUM; ++i) {
p=radixArr[i]->next;
while(p) {
arr[j++] = p->value;
p=p->next;
}
}
}


int findMax(int arr[], int n) {                        //输出数组中最大的数
int i;
int max=0;
for(i=0;i<n;++i) {
if(max<arr[i]) {
max=arr[i];
}
}
return max;
}


int maxBitNum(int value) {                           //输出数组中最大数的位数（111的位数是3）
int i=0;
do{
i++;
value/=10;
}while(value);
return i;
}


int valueInBit(int value, int bitNum) {            //相应bitNum位上的数字
int i;
while(bitNum) {
i = value%10;
value/=10;
bitNum--;
}
return i;
}


void insertInEnd(pnode head,int value) {                              //尾部插入数据
pnode p;
pnode cur;
if(NULL==head) {
return;
}
p=head;
while(p->next) {
p=p->next;
}
cur=(pnode) malloc(sizeof(struct node));
if(!cur) {
return;
}
cur->value = value;
cur->next = NULL;
p->next=cur;
}


void deleteList(pnode head){                        //清空链表
pnode next=NULL;
pnode cur=NULL;
if(NULL==head) {
return;
}
cur=head;
while(cur) {
next=cur->next;
free(cur);
cur=next;
}
}