基数排序

基数排序类似于桶排序

基数排序首先找到最大值，确定入桶次数，如果最大值是百位的就入桶出桶三次，以此类推

由于为了方便，我们创建10个桶，因为每一位最多就10种数(0-9)

首先先以个位数字入桶，然后将桶中的元素出桶重新装到原数组里

循环操作，最后原数组中得到的数据就是有序的

在我理解基数排序，首先排完个位之后，再排十位，那么十位相同但是个位低的会先入桶

也就是说十位数变成了有序的了，排完十位再排百位，那么百位数相同但是十位数低的会先入桶,

所以也就实现了排序

 

typedef struct NODE
{
    int nValue;
    struct NODE* pNext;
}Node;
int GetTenMi(int count)
{
    int temp = 1;
    while(count != 0)
    {
        temp *= 10;
        count--;
    }
    return temp;
}

void RadixSort(int* arr,int length)
{
    if(arr == NULL || length <= 0) return;
    
    int min;
    int max;
     //得到最大值 
    if(length/2*2 != length)
    {
        max = arr[0];
        min = arr[0];
        int a;
        int b;
        for(int i=1;i<length;i+=2)
        {
            a = arr[i]>arr[i+1]?arr[i]:arr[i+1];
            b = arr[i]<arr[i+1]?arr[i]:arr[i+1];
            max = max>a?max:a;
            min = min<b?min:b;
        }
    }
    else
    {
        max = arr[0]>arr[1]?arr[0]:arr[1];
        min = arr[0]<arr[1]?arr[0]:arr[1];
        int a;
        int b;
        for(int i=2;i<length;i+=2)
        {
            a = arr[i]>arr[i+1]?arr[i]:arr[i+1];
            b = arr[i]<arr[i+1]?arr[i]:arr[i+1];
            max = max>a?max:a;
            min = min<b?min:b;
        }
    }
    int count = 0;
    int temp = max;
    while(temp != 0)
    {
        temp /=10;
        count++;
    }
    //创建桶 
    Node** ptemp = (Node**)malloc(sizeof(Node*)*10);
    memset(ptemp,0,sizeof(Node*)*10);
    for(int i=0;i<count;i++)
    {
        //往桶里添加 
        for(int j=0;j<length;j++)
        {
            Node* p = (Node*)malloc(sizeof(Node));
            p->nValue = arr[j];
            p->pNext = NULL;

            int index = arr[j]/GetTenMi(i)%10;
            Node* bj = ptemp[index];
            if(bj == NULL)
            {
                ptemp[index] = p;    
                continue;
            }
            while(bj->pNext)
            {    
                bj = bj->pNext;
            }
            bj->pNext = p;
        }
        //装回原数组 
        int aa = 0;
        for(int j=0;j<10;j++)
        {
            Node* bj = ptemp[j];
            while(bj)
            {
                arr[aa] = bj->nValue;
                aa++;
                bj = bj->pNext;
            }
        }
        //删除 
        for(int j=0;j<10;j++)
        {
            if(ptemp[j])
            {
                Node* pDel = ptemp[j];
                ptemp[j] = ptemp[j]->pNext;
                free(pDel);
                pDel = NULL;
            }
        }
        memset(ptemp,0,sizeof(Node*)*10);
        
    }

}