基数排序

• 基数排序算法的思想很有趣，他不依靠比较排序。而是采用分配式排序。基数排序也称为桶排序。基数排序有最高位优先（MSD）和最低位优先(LSD)两种。下面以最低位优先为例。

原理

准备10个容器，编号0-9，对应数字0-9。 容器是有序的(按添加顺序)
然后按待排序元素的某一位(比如:个位/十位/白位)的数字将其存放到对应容器中（数字相同,如: 数字时1 就放在1号桶），
再将从0号容器开始依次到9号容器, 将其中的元素顺序取出。所以容器内的元素收集合并复制回原数组，然后再从下一位开始…

这里假设数组元素都是3位数。从个位开始，将数组中的元素按个位数字放入对应的桶中，再从桶中顺序取出到数组，这是数组按个位数字有序排列，再以相同的逻辑处理十位和百位。最后数组中就是有序的了

示例代码1

示例算法测试效率并不高（测试数据的位数是3位，数量是15万。）远低于快速排序，不过这和算法无关，而是因为示例中使用链表作为容器（桶），catch命中低，导致内存访问频繁造成的。

class RadixSort{
    private Node[] links = new Node[10];
    private byte digits = 3;//元素的位数
    public void sort(int[] arr){
        int count  = 1;
        for(int j = 0;j < digits; j++){
            //一遍循环处理一位
            for(int i = 0;i < arr.length; i++){
                add(new Node(arr[i]),(arr[i]/count) % 10);
            }
            copy(arr);
            count*=10;
        }

    }
    private void copy(int[] arr) {
        // 把链表中的元素复制回数组
        int k = 0;//数组下标
        for(int i = 0; i < 10; i++){
            while(links[i] != null){
                arr[k++] = links[i].getValue();
                links[i] = links[i].getNext();
            }
        }
    }

    private void add(Node node, int index) {

        if(links[index] == null){
            //链表为null 新元素放在首位
            links[index] = node;
        }else{
            //遍历链表，找到最后一个节点
            Node flag = links[index];
            while(flag.getNext() != null){
                flag = flag.getNext();
            }
            flag.setNext(node);
        }
    }

}
class Node{
    private int value;
    private Node next;

    public Node(int value) {

        this.next = null;
        this.value = value;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
}

改进

使用集合替换链表, 效率提升很大(100x)

/*
 * 改进 2017/10/28
 * radixSort1性能并不好,是因为链表cache命中太低
 * 现在用集合代替链表
 * 结论: 使用LinkedList效率和ArrayList相差无几,  是否说明和cache命中无关, 只是自己实现的链表效率太低...
 * */

class RadixSort2{
	
	private byte digits = 3;//元素的位数
	private List[] list = new List[10];
	
	public RadixSort2(){
		super();
		for(int i = 0; i < list.length; i++){
			//LinkedList和ArrayList性能相当,  ArrayList指定容量与不指定相当. 奇怪
			list[i] = new ArrayList(10000);
		}
	}
	
	
	public void sort(int[] arr){
		int count  = 1;
		for(int j = 0;j < digits; j++){
			//一遍循环处理一位
			for(int i = 0;i < arr.length; i++){
				//add(new Node(arr[i]),(arr[i]/count) % 10);
				list[(arr[i]/count) % 10].add(arr[i]);
			}
			copy(arr);
			count*=10;
		}
	}
	private void copy(int[] arr) {
		// 把链表中的元素复制回数组
		int k = 0;//数组下标
		for(int i = 0; i < list.length; i++){

			for(Object o : list[i]){
				arr[k++] = (Integer)o;
			}
			list[i].clear() ;
		}
	}
}