#define Radix 10
#define MaxDigit 4

typedef struct ENode{ //定义元素结点
    int data;
    struct ENode *next;
}*PtrToNode;
typedef struct BucketNode{ //定义桶结点结构
    PtrToNode head;
    PtrToNode tail;
}*Bucket;

void LSDRadix_Sort(int A[], int N){ //基排序
    int i, D; //D为位， d为第D位上的数字（范围为0到9）
    //定义两个大小为Radix的桶，并初始化
    Bucket B1 = malloc(Radix * sizeof(struct BucketNode));
    Bucket B2 = malloc(Radix * sizeof(struct BucketNode));
    for(i=0; i<Radix; i++){
        B1[i].head = B1[i].tail = B2[i].head = B2[i].tail = NULL;   //注意大bug：B1为桶指针，但是B1[i]为结构体
    }
    //将数组中元素按照倒数第D位数字分别挂到桶B1上
    D = 1;
    Transfer_Array_To_Bucket(A, B1, N, D);
    D++;
    //开始相互倒腾，每倒腾一趟就往前看一位
    while(D <= MaxDigit){
        if(D % 2 == 0)
            Transfer_Bucket_To_Bucket(B1, B2, D);
        else
            Transfer_Bucket_To_Bucket(B2, B1, D);
        D++;
    }
    //倒腾结束后将桶中的元素依次倒入数组A中
    if(D % 2 == 0)
        Transfer_Bucket_To_Array(B1, A, N);
    else
        Transfer_Bucket_To_Array(B2, A, N);
    //释放两个桶及其元素
    Free_Bucket(B1);
    Free_Bucket(B2);
    return;
}

void Transfer_Array_To_Bucket(int A[], Bucket B, int N, int D){ //将数组A中元素按照第D位挂到桶B中
    int i, d;
    PtrToNode temp;
    for(i=0; i<N; i++){
        d = Get_Digit(A[i], D); //获取A[i]倒数第D位数字
        temp = malloc(sizeof(struct ENode)); //创建一个新结点并初始化
        temp->data = A[i];
        temp->next = NULL;
        if(B[d].tail == NULL){ //若桶的d位置上为空
            B[d].head = B[d].tail = temp;
        }else{
            B[d].tail->next = temp;
            B[d].tail = temp;
        }
    }
    return;
}

void Transfer_Bucket_To_Array(Bucket B, int A[], int N){ //将桶B1中元素依次倒入数组A中，最多不超过N
    int k, i = 0;
    PtrToNode p;

    for(k=0; k<Radix; k++){
        p = B[k].head;
        while(p != NULL){
            if(i < N){
                A[i++] = p->data;
                p = p->next;
            }else{
                return;
            }
        }
    }
    return;
}

void Transfer_Bucket_To_Bucket(Bucket B1, Bucket B2, int D){ //依次将桶B1中元素按照第D位挂到B2中，
    int k, d;
    PtrToNode p, temp;
    //依次从B1中取下元素结点，根据D位数字挂到B2上
    for(k=0; k<Radix; k++){
        p = B1[k].head;
        while(p != NULL){
            //从B1中取该元素，并获取第D位数字
            temp = p;
            p = p->next;
            d = Get_Digit(temp->data, D); //获取该结点第D位数字
            //将该元素挂到B2上
            temp->next = NULL; //肯定作为本次转移的尾结点
            if(B2[d].head == NULL){ //若B2[d]为空位置
                B2[d].head = B2[d].tail = temp;
            }else{ //若B2[d]不为空位置，则将temp结点接到尾结点上
                B2[d].tail->next = temp;
                B2[d].tail = temp;
            }
        }
        //取完B1[k]上的所有结点后，设置其首尾结点指针为空
        B1[k].head = B1[k].tail = NULL;
    }

    return;
}

int Get_Digit(int X, int D){  //获取X倒数第D位数字
    int k, i;
    for(i=0; i<D-1; i++)
        X = X / Radix;
    k = X % Radix;
    return k;
}