基数排序-----------------------RadixSort [LSD]

解决思想：

1   首先找到待排序数组中的元素的最大值 

2   求解最大值得数据的位数（采用连续除以0的方法计数，每当记一次数后将数据除以10，结束技术的条件是当数据的值为0）

3    开辟指针数组（数组的大小为了简化问题的操作难度，将数组的长度设置为10），用来装链表的头指针

4    待排序的数据按照先后顺序依次装入指针数组对应的链表中（插入的规则是首先取出每一个元素的个位上的数据，开辟节点粗怒这个元素的实际数值，根据个位的数值将相应的节点加载到对应的链表上【根据个位上的数值加载，0-----9分别对应之前开辟的指针数组】，连续的循环操作，操作的结束条件是，直到达到真实数据的最大值的数据位数） 

5    将指针数组中的每一个链表上的数据加载到原始数组中，清空指针数组中的每一个链表中的节点

6    继续执行操作4和5 ，直到操作的次数达到最大数据的数据位数时结束操作

7    操作结束，释放开辟的指针数组

基数排序的操作完成 

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

typedef struct node
{
    int value;
    struct node *next;
}RadixSort;

//查找待排序数组中的最大值

int Max_funcation(int a[],int len){
    if(a==NULL || len<=0)  return -1;
    int max=a[0];
    int i;
    for(i=1;i<len;i++){
        if(a[i]>max){
            max=a[i];
        }
    }
    return max;
}

//查找最大值的数据位数  提供给排序的操作条件【用于是否达到排序结束】

int Max_count(int max){
    int count=0;
    while(max!=0){
        max/=10;
        count++;
    }
    return count;
}

void funcation(int a[],int len){
    if(a==NULL || len<=0)  return ;
    int count;
    count=Max_count(Max_funcation(a,len));
    int i;

    //开辟指针数组 【空间的大小是10】---------------用于装每一个链表的头指针
    RadixSort **bucket=NULL;
    bucket=(RadixSort **)malloc(sizeof(RadixSort *)*10);

    //初始化开辟的指针数组 赋值为空
    memset(bucket,0,sizeof(RadixSort *)*10);
    int n;
    int j;
    int k;
    int temp;
    RadixSort *bj_node=NULL;
    RadixSort *insert=NULL;    

    //开始排序操作【排序结束的条件是直到达到最大数值的数据位数时候  结束操作】 
   for(i=1;i<=count;i++){
        n=1;
        int bj_date=i;
        while(bj_date>1){
            n*=10;
            bj_date--;
        }

        //数据进入指针数组所对应的链表中
        for(k=0;k<len;k++){
            temp=a[k]/n%10;
            insert=(RadixSort*)malloc(sizeof(RadixSort));
            insert->value=a[k];
            insert->next=NULL;
            //尾添加
            if(bucket[temp] == NULL){
                bucket[temp]=insert;
            }
            else{
                bj_node=bucket[temp];
                while(bj_node->next != NULL){
                    bj_node=bj_node->next;
                }
                bj_node->next=insert;
            }
        }
        //将指针数组对应的链表中的数据写会原始的数组
        k=0;
        for(j=0;j<10;j++){
            bj_node=bucket[j];
            while(bj_node){
                a[k]=bj_node->value;
                
                bj_node=bj_node->next;
                k++;
            }    
        }
        //将指针的数组的每一个链表清空
        RadixSort *m_node=NULL;
        for(j=0;j<10;j++){
            bj_node=bucket[j];
            while(bj_node){
                m_node=bj_node;
                bj_node=bj_node->next;
                free(m_node);
                m_node=NULL;
            }
        }

        //将指针数组的每一个元素赋值为空 
       memset(bucket,0,sizeof(RadixSort*)*10);
    }

    //排序结束的时候释放开辟的指针数组
    free(bucket);
    bucket=NULL;
}

int main(){
    int a[]={11,100,20,30,1,0,7,8,99};
    funcation(a,sizeof(a)/sizeof(a[0]));
    for(int i=0;i<sizeof(a)/sizeof(a[0]);i++){
        printf("%d ",a[i]);
    }
    printf("\n");
    return 0;
}