基数排序

#include  < stdio.h >
#define  MAX_NUM_OF_KEY 2
#define  RADIX 10  // 基数
#define  MAX_SPACE 100

typedef  struct
... {
    int keys[MAX_NUM_OF_KEY];
    int next;
} SLCell;

typedef  struct
... {
    SLCell r[MAX_SPACE];
    int keynum;
    int recnum;
} SLList;

typedef  int  ArrType[RADIX];

void  Distribute(SLList  & L,  int  i, ArrType  & f, ArrType  & e) 
... {  
  // 算法10.15
  // 静态链表L的r域中记录已按(keys[0],...,keys[i-1])有序，
  // 本算法按第i个关键字keys[i]建立RADIX个子表，
  // 使同一子表中记录的keys[i]相同。f[0..RADIX-1]和e[0..RADIX-1]
  // 分别指向各子表中第一个和最后一个记录。
  int j, p;
  for (j=0; j<RADIX; j++) 
      f[j] = 0;     // 各子表初始化为空表
  for (p = L.r[0].next;  p; p = L.r[p].next) 
  ...{
    j = L.r[p].keys[i];  // 将记录中第i个关键字映射到[0..RADIX-1]，
    if(!f[j]) 
        f[j] = p;
    else 
        L.r[e[j]].next = p;
    e[j] = p;                // 将p所指的结点插入第j个子表中
  }
}   //  Distribute


void  Collect(SLList  & L,  int  i, ArrType  & f, ArrType  & e) 
... { // 算法10.16
  // 本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成
  // 一个链表，e[0..RADIX-1]为各子表的尾指针
  int j, t;
  for (j=0; !f[j]; j++);  // 找第一个非空子表，succ为求后继函数: ++
  L.r[0].next = f[j];  // L.r[0].next指向第一个非空子表中第一个结点
  t = e[j];
  while (j < RADIX) 
  ...{
    for (j = j + 1; j < RADIX && !f[j]; j++);       // 找下一个非空子表
    if (j < RADIX) // 链接两个非空子表
    ...{
        L.r[t].next = f[j];
        t = e[j];
    }
  }
  L.r[t].next = 0;   // t指向最后一个非空子表中的最后一个结点
}   //  Collect


void  RadixSort(SLList  & L) 
... {  // 算法10.17
   // L是采用静态链表表示的顺序表。
   // 对L作基数排序，使得L成为按关键字自小到大的有序静态链表，
   // L.r[0]为头结点。
   int i;
   ArrType f, e;
   for(i=1; i <= L.recnum; i++) 
       L.r[i-1].next = i;
   L.r[L.recnum].next = 0;     // 将L改造为静态链表
   for(i = 0; i < L.keynum; i++) 
   ...{  
      // 按最低位优先依次对各关键字进行分配和收集
      Distribute(L, i, f, e);    // 第i趟分配
      Collect(L, i, f, e);       // 第i趟收集
   }
}   //  RadixSort


int  main()
... {
    SLList list;
    int i, j, m, n;
    printf("请输入需要排序的数的个数: ");
    scanf("%d", &n);
    printf("请输入%d个数 ", n);
    for(i = 1; i <= n; i++)
    ...{
        scanf("%d", &m);
        list.r[i].keys[0] = m % 10;
        list.r[i].keys[1] = m / 10;
    }
    list.keynum = 2;
    list.recnum = n;
    RadixSort(list);
    printf("经过排序以后的数列 ");
    for(j = list.r[0].next;  j; j = list.r[j].next)
        printf("%5d", list.r[j].keys[1] * 10 + list.r[j].keys[0]);
    printf(" ");//实际上原序列依然没有改变，只不过它们的next变了
}