【排序算法（七）】基数排序

基本思想

基数排序(Radix Sort)是桶排序的扩展，它的基本思想是：将整数按位数切割成不同的数字，然后按每个位数分别比较。
具体做法是：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

通过基数排序对数组{53, 3, 542, 748, 14, 214, 154, 63, 616}，它的示意图如下：

在上图中，首先将所有待比较树脂统一为统一位数长度，接着从最低位开始，依次进行排序。

1. 按照个位数进行排序。
2. 按照十位数进行排序。
3. 按照百位数进行排序。
   排序后，数列就变成了一个有序序列。

java版本实现

package sort;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class RadixSort{
	
	private int a[];
	
	public RadixSort(int a[]) {
		this.a = a;
	}
	
	public void radixSort() {
		
		int n = a.length - 1;
		
		//找到最大值
		int max = a[0];
		for(int i = 1 ; i < n ; i ++)
			if(a[i] > max)
				max =a[i];
		
		//求出最大值有多少位
		int keysNum = 0;
		while( max > 0 ) {
			max /= 10;
			keysNum ++;
		}
		
		List<LinkedList<Integer>> buckets = new ArrayList<>();
		for(int i = 0 ; i < 10 ; i ++)
			buckets.add(new LinkedList<>());
		
		for(int i = 0 ; i < keysNum ; i ++) {
			countSort(buckets , i);	
		}
		
	}

	private void countSort(List<LinkedList<Integer>> buckets, int i) {
		for(int j = 0 ; j < a.length  ; j ++) {
			int key = (int) (a[j] % Math.pow(10, i + 1) / Math.pow(10, i));
			buckets.get(key).add(a[j]); 
		}
	
		int count = 0 ;
		for(int k = 0 ; k < 10 ; k ++) {
			LinkedList<Integer> bucket = buckets.get(k);
			while(bucket.size() > 0) {
				a[count ++] = bucket.remove(0);
			}
		}
		
		System.out.print("the " + ( i + 1 ) +" time sort: ");
		display();
		
	}

	private void display() {
		for(int i = 0 ; i < a.length ; i ++ )
			System.out.print(a[i] + "   ");
		System.out.println();
	}
	
	public static void main(String[] args) {
		int[] a = {53, 3, 542, 748, 14, 214, 154, 63, 616, 55 , 58};
		RadixSort rs = new RadixSort(a);
		System.out.print("before     sort: ");
		rs.display();
		rs.radixSort();
	}
}

算法分析

初看起来，基数排序的执行效率似乎好的让人无法相信，所有要做的只是把原始数据项从数组复制到链表，然后再复制回去。如果有10个数据项，则有20次复制，对每一位重复一次这个过程。假设对5位的数字排序，就需要205=100次复制。如果有100个数据项，那么就有2005=1000次复制。复制的次数与数据项的个数成正比，即O(n)。这是我们看到的效率最高的排序算法。

不幸的是，数据项越多，就需要更长的关键字，如果数据项增加10倍，那么关键字必须增加一位（多一轮排序）。复制的次数和数据项的个数与关键字长度成正比，可以认为关键字长度是N的对数。因此在大多数情况下，基数排序的执行效率倒退为O(N*logN)，和快速排序差不多。