单链表实现基数排序

/*
  单链表实现基数排序
*/

/*接口头文件*/
typedef int ElementType;

#ifndef _LIST_H
#define _LIST_H
#include <stdbool.h>

struct Node;
typedef struct Node * PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

/*操作集*/
List MakeEmpty( List L );
bool IsEmpty( List L );
bool IsLast( Position P );
Position First( List L );
Position Header( List L );
void Insert( ElementType X, List L, Position P );
void DeleteList( List L );
Position Advance( Position P );
void RadixSortList( ElementType A[], int N, int P );
void PrintfList(List L);

#endif  


/*接口实现*/
#include <stdio.h>
#include <stdlib.h>
#include "list.h"
#define B 10

/*特定结构声明*/
struct Node
{
    ElementType Element;
    Position Next;
};

/*获取n的个位、十位、百位…具体位值由p指定。如，p = 1，取个位；p = 2，取十位。*/
int GetWei( int n, int p );

/*获取每个桶的尾部位置*/
Position GetLast( List L );

List MakeEmpty( List L )
{
    if ( L != NULL )
       DeleteList( L );
    L = ( List )malloc( sizeof( struct Node ) );
    if ( L == NULL )
    {
       printf( "No Space!!!
" );
       exit( 1 );
    }
    L->Next = NULL;
    
    return L;
}

bool IsEmpty( List L )
{
    return L->Next == NULL;
} 

bool IsLast( Position P )
{
    return P->Next == NULL;
}

Position Header( List L )
{
    return L;
}

Position First( List L )
{
    return L->Next;
}

void Insert( ElementType X, List L, Position P )
{
    Position Temp;
    Temp = ( List )malloc( sizeof( struct Node ) );
    if ( Temp == NULL )
    {
       printf( "No Space!!!
" );
       exit( 1 );
    }
    Temp->Element = X;
    
    Temp->Next = P->Next;
    P->Next = Temp;
}

void DeleteList( List L )
{
    Position P;
    Position Temp;
    
    P = L->Next;
    L->Next = NULL;     //保留头结点
    
    while ( P != NULL )
    {
        Temp = P->Next;
        free( P );
        P = Temp;
    } 
} 

Position Advance( Position P )
{
    return P->Next;
}

void RadixSortList( ElementType A[], int N, int P )
{
    List Bucket[B];
    Position Temp;
    int i, j, k, m, r;
    
    /*根据待排序数据位数决定排序趟数*/
    for ( i = 1; i <= P; i++ )
    {
        /*创建桶*/
        for ( j = 0; j < B; j++ )
            Bucket[j] = MakeEmpty( NULL );
        
        /*分配*/
        for ( k = 0; k < N; k++ )
            Insert( A[ k ], Bucket[ GetWei( A[ k ], i ) ], GetLast( Bucket[ GetWei( A[ k ], i ) ] ) );
        
        /*输入*/
        
        for ( m = 0, r = 0; m < B && r < N; m++ )
        {
            Temp = First( Bucket[ m ] );
            while ( Temp != NULL )
            {
                A[ r ] = Temp->Element;
                r++;
                Temp = Advance( Temp );
            }
        }
    } 
}

Position GetLast( List L )
{
    Position P;
    
    if ( L == NULL )
    {
       printf( "No Space!!!
" );
       exit( 1 );
    }
    else if ( L->Next == NULL )
    {
       
       return L;
    }
    else
    {
        P = First( L );
        while ( ! IsLast( P ) )
           P = Advance( P );
        
        
        return P;
    }
}

int GetWei( int n, int p )
{
    int temp, result;
    
    for ( int i = 0; i < p; i++ )
    {
        result = n % 10;
        n = n / 10;
    }
    
    return result;
}

void PrintfList(List L)
{
    Position P;
    
    if (IsEmpty(L))
       printf("List is empty!
");
    else
    {
       P = First(L);
       while (P != NULL)
       {
           printf("%4d",P->Element);
           P = Advance(P);
       }
       printf("
");
    }
}