链表的应用---基数排序

介绍基数排序前，先要介绍下桶排序

桶排序（bucket sort），就是知道数据的范围，然后定义这个范围大小的桶，然后再排序处理。如考卷成绩排序，分数范围是0-100，那么就要定义101个桶，如果有人考了100分，那么第100个桶，就需要+1，如果有人考了50分，那么就在第50个桶+1，以此类推。
桶排序一般用在知道数据范围的，且范围跨度不大的。比如，如果范围是1-99999，可能中间有很多数据都是用不到的，那么就造成了空间浪费。

基数排序（radix sort）是基于桶排序的一种扩展，它是从低位往高位逐位进行桶排序。
如，输入是20，1，45，22，60
从个位开始排序：20，60，1，22，45
从十位开始排序：1，20，22，45，60
最高位排序完成后，就得到最后排序的表了。

具体实现如下

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

#define LIST_LEN 10
#define NUMBER_LEN 3

typedef struct _Node_T
{
    int * number;
    int length;
    int listMaxLen;
}Node;

typedef struct _Node_T * LIST;

LIST radix_sort_init_list(void)
{
    LIST l = (LIST)malloc(sizeof(Node));
    if(NULL == l)
    {
        printf("List malloc fail!\n");
        return NULL;
    }
    memset(l, 0, sizeof(Node));

    l->number = (int *)malloc(LIST_LEN * sizeof(int));
    if(NULL == l->number)
    {
        printf("List->number malloc fail!\n");
        return NULL;
    }
    memset(l->number, 0, LIST_LEN * sizeof(int));

    l->length = 0;
    l->listMaxLen = LIST_LEN;    

    return l;
}

void radix_sort_insert(LIST list, int number)
{
    if(list->length >= LIST_LEN)
    {
        printf("List is Full, cannot insert!\n");
        return;
    }

    list->number[list->length] = number;
    list->length++;
}

void radix_sort_traverse(LIST list)
{
    int i=0;

    for(i=0; i<list->length; i++)
        printf("%3d  ", list->number[i]);

    printf("\n");
}


int radix_sort_get_digit(int number, int index)
{
    switch(index)
    {
        case 1:
            return number%10;
        case 2:
            return (number/10)%10;
        case 3:
            return (number/100)%10;
        case 4:
            return (number/1000)%10;
        case 5:
            return (number/10000)%10;
        default:
            printf("It is bigger than the max number len!\n");
    }

    return 0;
}

void radix_sort_proc(LIST list)
{
    int i, j, k, temp;

    for(k=1; k<=NUMBER_LEN; k++)
    {
        for(i=0; i<list->length; i++)
        {
            for(j=i+1; j<list->length; j++)
            {
                if(radix_sort_get_digit(list->number[i], k) > radix_sort_get_digit(list->number[j], k))
                {
                    temp = list->number[i];
                    list->number[i] = list->number[j];
                    list->number[j] = temp;    
                }
            }
        }
    }
}

void radix_sort_main_test(void)
{
    LIST list;

    list = radix_sort_init_list();

    radix_sort_insert(list, 64);
    radix_sort_insert(list, 8);
    radix_sort_insert(list, 216);
    radix_sort_insert(list, 512);
    radix_sort_insert(list, 27);
    radix_sort_insert(list, 729);
    radix_sort_insert(list, 0);
    radix_sort_insert(list, 1);
    radix_sort_insert(list, 343);
    radix_sort_insert(list, 125);

    radix_sort_proc(list);

    radix_sort_traverse(list);    
}