看了幾篇文章，發現基數排序已經有很好的帖子，自認爲自己如果寫也沒有這篇文章寫得好，所以本篇博客就不在重複寫基數排序了，只是他那篇文章沒有Java版本，所以我把那篇文章移動過來，再加上我的Java代碼就OK了！（以下文章引自http://www.cnblogs.com/Braveliu/archive/2013/01/21/2870201.html)
編程論到極致，核心非代碼，即思想。
所以，真正的編程高手同時是思想獨到及富有智慧（注意與聰明區別）的人。
每一個算法都是一種智慧的凝聚或萃取，值得我們學習從而提高自己，開拓思路，更重要的是轉換思維角度。
其實，我們大多數人都活在“默認狀態”下。沒有發覺自己的獨特可設置選項-----思想。
言歸正傳（呵呵！恢復默認狀態），以下學習基數排序。
【1】基數排序
以前研究的各種排序算法，都是通過比較數據大小的方法對欲排數據序列進行排序整理過程。
而基數排序卻不再相同，那麼，基數排序是採用怎樣的策略進行排序的呢？
簡略概述：基數排序是通過“分配”和“收集”過程來實現排序。而這個思想該如何理解呢？請看以下例子。
（1）假設有欲排數據序列如下所示：
73 22 93 43 55 14 28 65 39 81
首先根據個位數的數值，在遍歷數據時將它們各自分配到編號0至9的桶（個位數值與桶號一一對應）中。
分配結果（邏輯想象）如下圖所示：
分配結束後。接下來將所有桶中所盛數據按照桶號由小到大（桶中由頂至底）依次重新收集串起來，得到如下仍然無序的數據序列：
81 22 73 93 43 14 55 65 28 39
接着，再進行一次分配，這次根據十位數值來分配（原理同上），分配結果（邏輯想象）如下圖所示：
分配結束後。接下來再將所有桶中所盛的數據（原理同上）依次重新收集串接起來，得到如下的數據序列：
14 22 28 39 43 55 65 73 81 93
觀察可以看到，此時原無序數據序列已經排序完畢。如果排序的數據序列有三位數以上的數據，則重複進行以上的動作直至最高位數爲止。
那麼，到這裏爲止，你覺得你是不是一個細心的人？不要不假思索的回答我。不論回答什麼樣的問題，都要做到心比頭快，頭比嘴快。
仔細看看你對整個排序的過程中還有哪些疑惑？真看不到？覺得我做得很好？抑或前面沒看懂？
如果你看到這裏真心沒有意識到或發現這個問題，那我告訴你：悄悄去找個牆角蹲下用小拇指畫圈圈（好好反省反省）。
追問：觀察原無序數據序列中73 93 43 三個數據的順序，在經過第一次（按照個位數值，它們三者應該是在同一個桶中）分配之後，
在桶中順序由底至頂應該爲73 93 43（即就是裝的遲的在最上面，對應我們上面的邏輯想象應該是43 93 73），對吧？這個應該可以想明白吧？理論上應該是這樣的。
但是，但是，但是分配後很明顯在3號桶中三者的順序剛好相反。這點難道你沒有發現嗎？或者是發現了覺得不屑談及（算我貽笑大方）？
其實這個也正是基數排序穩定性的原因（分配時由末位向首位進行），請看下文的詳細分析。
再思考一個問題：既然我們可以從最低位到最高位進行如此的分配收集，那麼是否可以由最高位到最低位依次操作呢？ 答案是完全可以的。
基於兩種不同的排序順序，我們將基數排序分爲LSD（Least significant digital）或MSD（Most significant digital），
LSD的排序方式由數值的最右邊（低位）開始，而MSD則相反，由數值的最左邊（高位）開始。
注意一點：LSD的基數排序適用於位數少的數列，如果位數多的話，使用MSD的效率會比較好。
MSD的方式與LSD相反，是由高位數爲基底開始進行分配，但在分配之後並不馬上合併回一個數組中，而是在每個“桶子”中建立“子桶”，將每個桶子中的數值按照下一數位的值分配到“子桶”中。
在進行完最低位數的分配後再合併回單一的數組中。
（2）我們把撲克牌的排序看成由花色和麪值兩個數據項組成的主關鍵字排序。
要求如下：
花色順序：梅花<方塊<紅心<黑桃
面值順序：2<3<4<...<10<J<Q<K<A
那麼，若要將一副撲克牌排成下列次序：
梅花2，...，梅花A，方塊2，...，方塊A，紅心2，...，紅心A，黑桃2，...，黑桃A。
有兩種排序方法：
<1>先按花色分成四堆，把各堆收集起來；然後對每堆按面值由小到大排列，再按花色從小到大按堆收疊起來。----稱爲"最高位優先"(MSD)法。
<2>先按面值由小到大排列成13堆，然後從小到大收集起來；再按花色不同分成四堆，最後順序收集起來。----稱爲"最低位優先"(LSD)法。
【2】代碼實現
（1）MSD法實現
最高位優先法通常是一個遞歸的過程：
<1>先根據最高位關鍵碼K1排序，得到若干對象組，對象組中每個對象都有相同關鍵碼K1。
<2>再分別對每組中對象根據關鍵碼K2進行排序，按K2值的不同，再分成若干個更小的子組，每個子組中的對象具有相同的K1和K2值。
<3>依此重複，直到對關鍵碼Kd完成排序爲止。
<4> 最後，把所有子組中的對象依次連接起來，就得到一個有序的對象序列。
示例代碼如下：
#include<iostream>
#include<malloc.h>
using namespace std;
int getdigit(int x,int d)
{
int a[] = {1, 1, 10}; //因爲待排數據最大數據也只是兩位數，所以在此只需要到十位就滿足
return ((x / a[d]) % 10); //確定桶號
}
void PrintArr(int ar[],int n)
{
for(int i = 0; i < n; ++i)
cout<<ar[i]<<" ";
cout<<endl;
}
void msdradix_sort(int arr[],int begin,int end,int d)
{
const int radix = 10;
int count[radix], i, j;
//置空
for(i = 0; i < radix; ++i)
{
count[i] = 0;
}
//分配桶存儲空間
int *bucket = (int *) malloc((end-begin+1) * sizeof(int));
//統計各桶需要裝的元素的個數
for(i = begin;i <= end; ++i)
{
count[getdigit(arr[i], d)]++;
}
//求出桶的邊界索引，count[i]值爲第i個桶的右邊界索引+1
for(i = 1; i < radix; ++i)
{
count[i] = count[i] + count[i-1];
}
//這裏要從右向左掃描，保證排序穩定性
for(i = end;i >= begin; --i)
{
j = getdigit(arr[i], d); //求出關鍵碼的第d位的數字， 例如：576的第3位是5
bucket[count[j]-1] = arr[i]; //放入對應的桶中，count[j]-1是第j個桶的右邊界索引
--count[j]; //第j個桶放下一個元素的位置(右邊界索引+1)
}
//注意：此時count[i]爲第i個桶左邊界
//從各個桶中收集數據
for(i = begin, j = 0;i <= end; ++i, ++j)
{
arr[i] = bucket[j];
}
//釋放存儲空間
free(bucket);
//對各桶中數據進行再排序
for(i = 0;i < radix; i++)
{
int p1 = begin + count[i]; //第i個桶的左邊界
int p2 = begin + count[i+1]-1; //第i個桶的右邊界
if(p1 < p2 && d > 1)
{
msdradix_sort(arr, p1, p2, d-1); //對第i個桶遞歸調用，進行基數排序，數位降 1
}
}
}
void main()
{
int ar[] = {12, 14, 54, 5, 6, 3, 9, 8, 47, 89};
int len = sizeof(ar)/sizeof(int);
cout<<"排序前數據如下："<<endl;
PrintArr(ar, len);
msdradix_sort(ar, 0, len-1, 2);
cout<<"排序後結果如下："<<endl;
PrintArr(ar, len);
}
/*
排序前數據如下：
12 14 54 5 6 3 9 8 47 89
排序後結果如下：
3 5 6 8 9 12 14 47 54 89
*/（2）LSD法實現
最低位優先法首先依據最低位關鍵碼Kd對所有對象進行一趟排序，
再依據次低位關鍵碼Kd-1對上一趟排序的結果再排序，
依次重複，直到依據關鍵碼K1最後一趟排序完成，就可以得到一個有序的序列。
使用這種排序方法對每一個關鍵碼進行排序時，不需要再分組，而是整個對象組。
示例代碼如下：
#include<iostream>
#include<malloc.h>
using namespace std;
#define MAXSIZE 10000
int getdigit(int x,int d)
{
int a[] = {1, 1, 10, 100}; //最大三位數，所以這裏只要百位就滿足了。
return (x/a[d]) % 10;
}
void PrintArr(int ar[],int n)
{
for(int i = 0;i < n; ++i)
{
cout<<ar[i]<<" ";
}
cout<<endl;
}
void lsdradix_sort(int arr[],int begin,int end,int d)
{
const int radix = 10;
int count[radix], i, j;
int *bucket = (int*)malloc((end-begin+1)*sizeof(int)); //所有桶的空間開闢
//按照分配標準依次進行排序過程
for(int k = 1; k <= d; ++k)
{
//置空
for(i = 0; i < radix; i++)
{
count[i] = 0;
}
//統計各個桶中所盛數據個數
for(i = begin; i <= end; i++)
{
count[getdigit(arr[i], k)]++;
}
//count[i]表示第i個桶的右邊界索引
for(i = 1; i < radix; i++)
{
count[i] = count[i] + count[i-1];
}
//把數據依次裝入桶(注意裝入時候的分配技巧)
for(i = end;i >= begin; --i) //這裏要從右向左掃描，保證排序穩定性
{
j = getdigit(arr[i], k); //求出關鍵碼的第k位的數字， 例如：576的第3位是5
bucket[count[j]-1] = arr[i]; //放入對應的桶中，count[j]-1是第j個桶的右邊界索引
--count[j]; //對應桶的裝入數據索引減一
}
//注意：此時count[i]爲第i個桶左邊界
//從各個桶中收集數據
for(i = begin,j = 0; i <= end; ++i, ++j)
{
arr[i] = bucket[j];
}
}
free(bucket);
}
void main()
{
int br[10] = {20, 80, 90, 589, 998, 965, 852, 123, 456, 789};
cout<<"原數據如下："<<endl;
PrintArr(br,10);
lsdradix_sort(br, 0, 9, 3);
cout<<"排序後數據如下："<<endl;
PrintArr(br, 10);
}
/*
原數據如下：
20 80 90 589 998 965 852 123 456 789
排序後數據如下：
20 80 90 123 456 589 789 852 965 998
*/注意：以上兩種方法我們均用數組模擬桶，關於數組模擬桶詳細講解請參考隨筆《桶排序》
【3】基數排序穩定性分析
基數排序是穩定性排序算法，那麼，到底如何理解它所謂的穩定特性呢？
比如：我們有如下欲排數據序列：
下面選擇LSD邏輯演示
第一次按個位數值分配，結果如下圖所示：
然後收集數據結果如下：
第二次按十位數值分配，結果如下圖所示：
然後收集數據結果如下：
注意：分配時是從欲排數據序列的末位開始進行，逐次分配至首位。
好吧！排序結束。相信一定一目瞭然。在此不作贅述。
Good Good Study, Day Day Up.
順序 選擇 循環 堅持 總結
java版本代碼：
package com.tangbo;
import java.util.Arrays;
public class RadixSort {
public static void main(String[] args) {
int[] array = {9,8,10,56,333,45566,2345678,78,990,12,432,56};
print(radixSort(array,10,7));
}
/*
*array爲待排序數組,radix代表基數,distance代表排序元素的位數
*/
private static int [] radixSort(int[] array,int radix, int distance) //基於計數排序的基數排序算法
{
int length = array.length;
int[] temp = new int[length];//用於暫存元素
int[] count = new int[radix];//用於計數排序
int divide = 1;
for (int i = 0; i < distance; i++) {
System.arraycopy(array, 0,temp, 0, length);
Arrays.fill(count, 0);
for (int j = 0; j < length; j++) {
int tempKey = (temp[j]/divide)%radix;
count[tempKey]++;
}
for (int j = 1; j < radix; j++) {
count [j] = count[j] + count[j-1];
}
//個人覺的運用計數排序實現計數排序的重點在下面這個方法
for (int j = length - 1; j >= 0; j--) {
int tempKey = (temp[j]/divide)%radix;
count[tempKey]--;
array[count[tempKey]] = temp[j];
}
divide = divide * radix;
}
return array;
}
static void print(int []array)//打印函數
{
for(int i=0;i<array.length;i++)
{
System.out.print(array[i]+" ");
}
System.out.println();
}
}