基數排序
- 基數排序算法的思想很有趣，他不依靠直接比較元素排序。而是采用分配式排序,單獨處理元素的每一位。從最高位向最低位處理 稱為:最高位優先（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() ;
}
}
}