基数排序

算法描述

多关键字排序：

又比如123，主位是1，次卫是3。

123，46,791。 按照次位优先     次位：791,123,46

                                         次次位：123,46,791

                                      次次次位：46,123,791

具体实现

建立桶元素结点，用链表实现。

建立桶头尾结点结构体。

构造GetDigit ( int X, int D )函数 用来得到X的D位的数字

构造LSDRadixSort( ElementType A[], int N )

 {

      初始化每个桶为空链表

      将原始序列逆序存入初始链表List

      排序

      {  

               对数据的每一位循环处理

               {

                 获得当前元素的当前位数字 

                 从List中摘除

                 插入B[Di]号桶尾

               }

       }

      收集（将每个桶的元素顺序收集入      将List倒入A[]并释放

#define MaxDigit 4
#define Radix 10
typedef struct Node *PtrToNode;
struct Node
{
    int key;
    PtrToNode Next;    
};
//定义桶头节点
struct HeadNode
{
    PtrToNode head;
    PtrToNode tail;
};
typedef struct HeadNode Bucket[Radix];
/*
   X是所求的数，X是几位数 D就是几
*/
int GetDigital(int X,int D)
{
    int i,d;                 //d为返回值，是X在某位上的具体数
    for(i=1;i<=D;i++)
    {
        d=X%Radix;             //Radix =10;
        X/=Radix;             //Radix =10;
    }
    return d;
}
void LSDRadixSort(ElementType A[],int N)
{
    Bucket B;
    int i ,D,Di;
    PtrToNode P,temp,list=NULL;

    /*初始化桶*/
    for(i=0;i<Radix;i++)
   
        B[i].head=B[i].tail=NULL;
    
   /*将数组逆序导入链表list*/
    for(i=0;i<N;i++)
    {
        temp=(PtrToNode)malloc(sizeof( struct Node));  //新建temp
        temp->key=A[i];     
        temp->Next=list;    // 第一次temp为list list为null
        list=temp;          //更新list 为temp
    }
    
    /*从最低位开始入桶*/

    for(D=1;D<=MaxDigit;D++)
    {    
        P=list;
        while(P)
        {
            Di=GetDigital(P->key,D);
            /*获取位数*/
            temp=P;
            P=P->Next;
            temp->Next=NULL;
            /*从list中摘除*/
            if(B[Di].head==NULL)
                B[Di].head=B[Di].tail=temp;
            else
            {
                B[Di].tail->Next=temp;
                B[Di].tail=temp;
            }
        }
    
    /*收集*/
        list=NULL;
        for(Di=Radix-1;Di>=0;Di--)
        {
            if(B[Di].head)
            {
                B[Di].tail->Next=list;
                list=B[Di].head;
                B[Di].head=B[Di].tail=NULL;//清空桶
            }
        }
    }
    /* 将list倒入A[]并释放空间 */
    for(i=0;i<N;i++)
    {
        temp=list;
        list=list->Next;
        A[i]=temp->key;
    //    printf(" i: %d  a: %d   ",i,A[i]);
        free(temp);
    }
}

 错误分析：1.将82行的{  放在了70行。