基数排序

转自 http://blog.csdn.net/pigli/article/details/5755439

基数排序(Radix Sorting)：


基数排序是一种借助多关键字排序的思想对单逻辑关键字进行排序的方法。
1． 多关键字排序思想
      多关键字排序也就是对一个序列中每项数据都包含有多个关键字的序列进行排序。比如说对一幅扑克牌进行排序，扑克牌就包括花色和面值这两个关键字。有两种排序方法：
      第一种方法：按照花色我们将扑克牌分成四堆。然后再对每堆扑克按照面值的大小进行排序。最后，按照花色大小顺序将这四队扑克牌收成一堆。这样扑克牌就排序好了。
      第二种方法：首先按照面值我们将扑克牌分成13堆。然后每堆按照花色顺序排列。也就是说，这13堆的最上面一张扑克的花色均为梅花(若小的排在上面，大的排在下面)。接着，我们将这最上面的13张梅花按照面值从小到大收集起来最为最下面的13张扑克，接着收集方块的13张扑克，以此直到收集完毕所以的扑克。这时，扑克的排序也进行完毕。
从上面的排序过程可以总结出多关键字排序的思想：首先按照某一个关键字进行排序，使序列按照一个关键排列有序，然后再在基础上对下一个关键进行排序，使得下一个关键字也有序，如此，只到所有的关键字均有需。
从上面的排序过程还可以看出多关键字的排序实际上包括两个过程：分配和收集。
2． 何为单逻辑关键字
      个人理解，但逻辑关键字是指将待排序列中元素拆分成多个关键字。而关键字序列由相同的元素组成。比如说将123这个三位数拆分成由1,2,3这三个关键字组成的多关键字序列。

 

基数排序，这个基radix就是指的关键字的取值范围，也即是关键字的个数。如：若对十进制数进行排序，经过拆分后，每个关键字都是由0-9之间的数组成，那么基就是为10。


下面描述对十进制数进行基数排序的具体方法：
1． 采用静态链表对待排序的元素进行存储，静态链表中存储的元素包括两个部分：数据域和next域。Next域用来存储，排在此元素之后的数据的位置。
2． 还需要两个int型辅助数组f[radix],e[radix]。在此例中radix==10。
F为头指针，e为尾指针。
3． 排序总体上来说是包括两个过程：分配和收集。下面来描述在一趟排序中的分配和收集的过程：
分配：总体上来说是将数据按照第一个关键字，将数据分配到各自的类别上。Radix代表的是相应的类别，f[radix]中存储的是这个类别的第一个元素的序号，e[radix]存储的是这个类别最后一个元素的序号。F e起到的是 一个指针表示的作用。
收集：总体上来说是将各个类别的数据按照类别大小依次串联起来。
注意一趟收集完毕之后，要将f和e数组进行清空。

具体实现如下：

 

[java] view plaincopy
 
  1. package search;  
  2. /* 
  3.  * 基数排序的基本原理其实是：使得一个关键字有序的基础上使得另外一个关键字也有序。当所有的关键字均有序的时候，有序的序列表也就出来了。 
  4.  * 基数排序要注意每走完一趟要清空指针数组f和e 
  5.  */  
  6. public class RadixSort {  
  7.     private node[] rlist;  
  8.     private int[] f;  
  9.     private int[] e;  
  10.     private int numOfKey;  
  11.       
  12.     class node{  
  13.         int key;  
  14.         int next;  
  15.           
  16.         public node(int key,int next)  
  17.         {  
  18.             this.key = key;  
  19.             this.next = next;  
  20.         }  
  21.     }  
  22.       
  23.     public RadixSort(int[] array,int numOfKey)  
  24.     {  
  25.         rlist = new node[array.length+1];  
  26.         f = new int[10];  
  27.         e = new int[10];  
  28.         this.numOfKey = numOfKey;  
  29.         rlist[0] = new node(0,1);  
  30.         for(int i =0;i<array.length;i++)  
  31.         {  
  32.             if(i==array.length-1)  
  33.             {  
  34.                 rlist[i+1] = new node(array[i],0);  
  35.             }  
  36.             else  
  37.             {  
  38.                 rlist[i+1] = new node(array[i],i+2);  
  39.             }  
  40.         }  
  41.         for(int i=0;i<10;i++)  
  42.         {  
  43.             f[i] = 0;  
  44.             e[i] = 0;  
  45.         }  
  46.           
  47.     }  
  48.       
  49.     public void distribute(int i)  
  50.     {  
  51.         int p = rlist[0].next;  
  52.         while(p!=0)  
  53.         {  
  54.             int j = map(rlist[p],i);  
  55.             if(f[j]==0)  
  56.             {  
  57.                 f[j]=p;  
  58.             }  
  59.             else  
  60.             {  
  61.                 rlist[e[j]].next = p;  
  62.             }  
  63.             e[j] =p;  
  64.             p = rlist[p].next;  
  65.         }  
  66.     }  
  67.       
  68.     public void collect()  
  69.     {  
  70.         int i =0 ;  
  71.         int end =0;  
  72.         for(;f[i]==0;i++);  
  73.         rlist[0].next = f[i];  
  74.         end = e[i];  
  75.         while(i<10)  
  76.         {  
  77.             i++;  
  78.             if(i<10&&f[i]!=0)  
  79.             {  
  80.                 rlist[end].next = f[i];  
  81.                 end = e[i];  
  82.             }  
  83.         }  
  84.         rlist[end].next =0;  
  85.           
  86.     }  
  87.       
  88.     public int map(node p,int i)  
  89.     {  
  90.         int j =0;  
  91.         int data = p.key;  
  92.         switch(i)  
  93.         {  
  94.             case 1:  
  95.                 j = data%10;  
  96.                 break;  
  97.             case 2:  
  98.                 j = (data/10)%10;  
  99.                 break;  
  100.             case 3:  
  101.                 j = data/100;  
  102.                   
  103.         }  
  104.         return j;  
  105.     }  
  106.       
  107.     public void sort()  
  108.     {  
  109.         for(int i=1;i<=numOfKey;i++)  
  110.         {  
  111.             distribute(i);  
  112.             collect();  
  113.             clearArray();                                                          //这是需要着重注意的一点！  
  114.         }  
  115.     }  
  116.       
  117.       
  118.     public void print()  
  119.     {  
  120.         for(int i=rlist[0].next;i!=0;i = rlist[i].next)  
  121.         {  
  122.             System.out.print("key:"+rlist[i].key+"    "+"next:"+rlist[i].next);  
  123.             System.out.println();  
  124.         }  
  125.     }  
  126.       
  127.     public void clearArray()  
  128.     {  
  129.         for(int i=0;i<10;i++)  
  130.         {  
  131.             f[i] = 0;  
  132.             e[i] = 0;  
  133.         }  
  134.     }  
  135.       
  136.     public static void main(String args[])  
  137.     {  
  138.         int[] array = {567,678,567,45,46,26,345,378,23,257};  
  139.         RadixSort radixSort = new RadixSort(array,3);  
  140.         radixSort.sort();  
  141.         radixSort.print();  
  142.     }  
  143.       
  144. }  

 

posted @ 2014-06-13 02:19  princessd8251  阅读(200)  评论(0)    收藏  举报