基于单链表的基数排序，结构应该算挺简单的，容易懂

标题基于单链表的基数排序

1. 下面是代码，一个收集和一个分配
2. 问题在于收集和分配的集合无法再次利用，望大佬疏通一下脉络，太晚就先睡了，明天在想

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
typedef struct Lnod {
    int data;
    struct Lnod *next;
} Lnod;
//分配方法
void DistruSort(Lnod *p,Lnod *F[10],Lnod *E[10],int x) { //x表示个位还是百位1 表示个位i 2表示十位 3表示百位
    //建立n个存储指针的东西
    Lnod *p2;
    p2=p->next;
    int iu=0;
    while(p2!=NULL) {
            iu=(p2->data/(int)pow(10,x-1))%10;
            E[iu]->next=p2;
            E[iu]=p2;
            p2=p2->next;
            E[iu]->next=NULL;
    };
};
//收集方法
void PeiOption(Lnod *p,Lnod *F[10],Lnod *E[10]) {
    //开始收集
    int i=0;
    Lnod *p2;
    p2=p;
    for(i=0; i<10; i++) {
        while(F[i]->next!=NULL) {
            p2->next=F[i]->next;
            F[i]=F[i]->next;
            p2=p2->next;
        };
    };
    free(&*F);//
    free(&*E);//
};
int main() {
    Lnod *p3,*p,*p1,*p2;
    p=malloc(sizeof(struct Lnod));//头指针
    p->next=NULL;
    p2=p;
    int n;
    printf("请输入基数排序中的数据\n");
    scanf("%d",&n);
    Lnod *F[10];//分配
    Lnod *E[10];//收集
    int i=0;
    //初始化记录的存储数据结构
    for(i=0; i<10; i++) {
        p3=malloc(sizeof(struct Lnod));
        p3->next=NULL;
        E[i]=p3;
        F[i]=p3;
    };
    int m=0;
    //初始话需要排序的数据
    for(i=0; i<n; i++) {
        scanf("%d",&m);
        p1=malloc(sizeof(struct Lnod));
        p1->data=m;
        p1->next=NULL;
        p2->next=p1;
        p2=p1;
    };
    int h=1;//位数的标识
    Lnod *pi;
    for(h=1; h<=3; h++) {
        DistruSort(&*p,&*F,&*E,h);
        PeiOption(&*p,&*F,&*E);
        //把存储数据结果再次清空
        //这是一个大问题，会浪费很多空间，如果能够利用之前申请的就好了 太晚了该睡觉了
        for(i=0; i<10; i++) {
            p3=malloc(sizeof(struct Lnod));
            p3->next=NULL;
            E[i]=p3;
            F[i]=p3;
        };
        pi=p;
        while(pi->next!=NULL) {
            printf("%d\t",pi->next->data);
            pi=pi->next;
        };
        printf("\n");
    };
};
*优化*
对于每次重复调用收集和分配集合不需要再重新申请空间

 - 只需要在收集时，只需要把分配的头指针初始化。

代码
for(i=0; i<10; i++) {
            E[i]=F[i];//重置头指针  增加一个初始化指针就可以
        while(F[i]->next!=NULL) {
            p2->next=F[i]->next;
            F[i]=F[i]->next;
            p2=p2->next;
        };
    };
    

 - 最后在重复收集和分配时把F[] E[] 集合的指针的下一个指针都置为空
 代码
 		DistruSort(&*p,&*F,&*E,h);
        PeiOption(&*p,&*F,&*E);
        //把存储数据结果再次清空
        //这里置为空，不需要在重新分配新的内存
        for(i=0; i<10; i++) {
            E[i]->next=NULL;
            F[i]=E[i];
        };