基数排序
- 基数排序算法的思想很有趣，他不依靠直接比较元素排序。而是采用分配式排序,单独处理元素的每一位。从最高位向最低位处理 称为:最高位优先（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 Node[] endNode= 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;
endNode[index] = node;
}else{
/*
//遍历链表，找到最后一个节点
Node flag = links[index];
while(flag.getNext() != null){
flag = flag.getNext();
} flag.setNext(node);
*/
// 2018/1/26 修改：
//上面的遍历效率太差,所以改成下面这种
endNode[index].setNext(node);
endNode[index] = 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命中无关, 只是自己实现的链表效率太低...
* 2018/1/26 注：
* 自己实现的链表效率低是因为，每次添加元素都遍历链表了， 简直太愚蠢，， 即使是单链表也可以用一个引用指向尾节点啊！！
* */
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() ;
}
}
}