LSD Radix Sort,两个实现

自己用单链表实现如下：

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

/*Radix Sort*/
#define MAX_COUNT 100
#define BASE 10
typedef struct node snode;
typedef struct node* ptrtonode;
struct node
{
    int value;
    ptrtonode next;
};
ptrtonode create_newnode();
void make_empty(ptrtonode pnode);
void append_node(ptrtonode header,ptrtonode element);
void append_value(ptrtonode header,int value);
void print(int *array,int length);
void print_list(ptrtonode header);
void clear_list(ptrtonode header);

ptrtonode create_newnode()
{
    ptrtonode pnode=(ptrtonode)malloc(sizeof(snode));
    make_empty(pnode);
    return pnode;
}

void make_empty(ptrtonode pnode)
{
    pnode->value=0;
    pnode->next=NULL;
}

void append_node(ptrtonode header,ptrtonode element)
{
    ptrtonode position=header;
    while(position->next!=NULL)
    {
        position=position->next;
    }
    position->next=element;
}

void append_value(ptrtonode header,int value)
{
    ptrtonode element=create_newnode();
    element->value=value;
    element->next=NULL;
    append_node(header,element);
}

void print(int *array,int length)
{
    int i=0;
    for(i=0;i<length;i++)
    {
        printf("%d,",array[i]);
    }
    printf("\n");
}

void print_list(ptrtonode header)
{
    ptrtonode position=header->next;
    while(position!=NULL)
    {
        printf("%d,",position->value);
        position=position->next;
    }
    printf("\n");
}

void clear_list(ptrtonode header)
{
    ptrtonode position=header->next;
    ptrtonode temp;
    while(position!=NULL)
    {
        temp=position->next;
        free(position);
        position=temp;
    }
    header->next=NULL;
}

int main()
{
    int numbers[MAX_COUNT];
    int results[MAX_COUNT];
    int i=0;
    int maxValue=0;
    //init random numbers to sort
    for(i=0;i<MAX_COUNT;i++)
    {
        numbers[i]=rand();
        results[i]=numbers[i];
        if(numbers[i]>maxValue)
        {
            maxValue=numbers[i];
        }
    }
    printf("the random numbers:\n");
    print(numbers,MAX_COUNT);

    //get the digit
    i=maxValue;
    int digit=0;
    while(i!=0)
    {
        i=i/BASE;
        digit++;
    }
    printf("the digit is %d\n",digit);

    //init bucket
    ptrtonode buckets[BASE];
    for(i=0;i<BASE;i++)
    {
        buckets[i]=create_newnode();
    }

    int j,k,m,digitValue;
    for(j=0;j<digit;j++)
    {
        if(j==0)
        {
            k=1;
        }
        else
        {
            k*=10;
        }

        for(i=0;i<MAX_COUNT;i++)
        {
            digitValue=(results[i]/k)%BASE;
            append_value(buckets[digitValue],results[i]);
        }
        m=0;
        for(i=0;i<BASE;i++)
        {
            ptrtonode position=buckets[i];
            position=position->next;
            while(position!=NULL)
            {
                results[m]=position->value;
                position=position->next;
                m++;
            }
        }

        for(i=0;i<BASE;i++)
        {
            clear_list(buckets[i]);
        }
    }

    print(results,MAX_COUNT);
    return 0;
}

我们也可以纯数组实现，

这里给出的是wiki（http://en.wikipedia.org/wiki/Radix_sort）给出的用数组实现的版本：

#include <stdio.h>
#define MAX 5
#define SHOWPASS
void print(int *a, int n)
{
  int i;
  for (i = 0; i < n; i++)
    printf("%d\t", a[i]);
}

void radixsort(int *a, int n)
{
  int i, b[MAX], m = 0, exp = 1;
  for (i = 0; i < n; i++)
  {
    if (a[i] > m)
      m = a[i];
  }

  while (m / exp > 0)
  {
    int bucket[10] =
    {
      0
    };
    for (i = 0; i < n; i++)
      bucket[a[i] / exp % 10]++;
    for (i = 1; i < 10; i++)
      bucket[i] += bucket[i - 1];
    //Arrived here, the bucket array will store the index position of each element
    for (i = n - 1; i >= 0; i--)
      b[--bucket[a[i] / exp % 10]] = a[i];
    for (i = 0; i < n; i++)
      a[i] = b[i];
    exp *= 10;

    #ifdef SHOWPASS
      printf("\nPASS   : ");
      print(a, n);
    #endif
  }
}


int main()
{
  int arr[MAX];
  int i, n;


    n=5;
  printf("Enter %d Elements : ", n);
  for (i = 0; i < n; i++)
    arr[i]=rand();


  printf("\nARRAY  : ");
  print(&arr[0], n);

  radixsort(&arr[0], n);

  printf("\nSORTED : ");
  print(&arr[0], n);
  printf("\n");

  return 0;
}

显然算法二在性能上优于我自己实现的前一个，当然我实现的主要目的是为了学习单链表结构。

不论是哪一种实现，其核心思想是不变的，这在算法导论中定义的再精辟再清楚不过了：

RADIX_SORT(A,d)

1. for i=1 to d

2.       do use a stable sort to sort array A on digit i.