基数排序 C语言实现 基于单链表

代码

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100//单链表最大长度
typedef struct node{
    int key;
    struct node *next;
}List;//单链表

List *CreateList(){
    List *p,*s,*l=NULL;
    int n,i;
    printf("请输入待排序表的长度：");
    do{
        scanf("%d",&n);
        if(n<=0||n>MAXSIZE)
            printf("请输入大于0小于等于%d的长度：",MAXSIZE);
    } while (n<=0||n>MAXSIZE);
    printf("请输入%d个整数：",n);
    for(i=0;i<n;i++){
        if(l==NULL){
            p=(List *)malloc(sizeof(List));
            scanf("%d",&p->key);
            p->next=NULL;
            l=p;
        }else{
            s=(List *)malloc(sizeof(List));
            scanf("%d",&s->key);
            s->next=NULL;
            l->next=s;
            l=s;
        }
    }
    return p;
}//创建不带头单链表

void ShowList(List *r){
    List *p=r;
    while (p!=NULL){
        printf("%d\t",p->key);
        p=p->next;
    }
}//输出单链表

int GetNumInPos(int num,int pos){
    int temp=1;
    for(int i=1;i<pos;i++)
        temp*=10;
    return (num/temp)%10;
}//取某个数在pos位上的数

int GetDigitOfNum(int num){
    int n=1,temp=10;
    while(temp<=num){
        n++;
        temp*=10;
    }
    return n;
}//求某个数有多少位

int GetMaxDigitOfList(List *r){
    int n,max=0;
    List *p=r;
    while(p!=NULL){
        n=GetDigitOfNum(p->key);
        if(n>max)
            max=n;
        p=p->next;
    }
    return max;
}//求单链表中数的最大位数

void RadixSort(List *r){
    List *l,*p;
    int index[10][MAXSIZE];//二维数组分类，从上到下0~9，对应数字的每行可保存MAXSIZE个数
    int count[10];//用数组记录被分配基数个数
    int n,i,j,pos;
    for(pos=1;pos <= GetMaxDigitOfList(r);pos++){
        for(i=0;i<10;i++)
            count[i]=0;//开始或每当分类排序完初始为0
        p=r;
        while(p!=NULL){
            n=GetNumInPos(p->key,pos);//获取当前key中在pos位的数
            index[n][count[n]]=p->key;//index[基数][空位]=被分配数
            count[n]++;//对应0~9中，被分配进来的个数
            p=p->next;//定位下一个
        }//分配到数组
        l=r;
        for(i=0;i<10;i++){
            for(j=0;j<count[i];j++){
                l->key=index[i][j];
                l=l->next;
            }
        }//重新排序链表
        printf("第%d次排序：\n",pos);
        ShowList(r);
        printf("\n");
    }//从个位到十位再到百位等进行低位优先排序
}//基数排序

int main() {
    List *r;
    r=CreateList();
    printf("已创建单链表：\n");
    ShowList(r);
    printf("\n");
    RadixSort(r);
    printf("最终排序结果：\n");
    ShowList(r);
    return 0;
}

运行

原理

用一维数组保存排序数：

用二维数组保存分配数：

	0	1	2	3	4
0
1
2
3
4
5
6
7
8
9

例如要排序的数：

12	54	9	425	63	86	142

先按个位上的数分配：

	0	1	2	3	4
0
1
2	12	142
3	63
4	54
5	425
6	86
7
8
9	9

个位分配完后，按从上到下从左到右排序：

12	142	63	54	425	86	9

再按十位上的数分配：

	0	1	2	3	4
0	09
1	12
2	425
3	142
4
5	54
6	63
7
8	86
9

十位分配完后，按从上到下从左到右排序：

9	12	425	142	54	63	86

再按百位上的数分配：

	0	1	2	3	4
0	009	012	054	063	086
1	142
2
3
4	425
5
6
7
8
9

百位分配完后就是最终结果，按从上到下从左到右排序：

9	12	54	63	86	142	425

要排序的数中最大的数有多少位就分配排序多少次。