java基數排序

Ⅰ java數組冒泡排序還有什麼排序

常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，此外還有不常見的基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。

Ⅱ java 編寫一個程序,輸入3個整數,然後程序將對這三個整數按照從大到小進行排列

輸入三個數你可以這樣
Scanner in=new Scanner(System.in);
int a=in.nextInt();
Scanner in=new Scanner(System.in);
int b=in.nextInt();
Scanner in=new Scanner(System.in);
int c=in.nextInt();
然後對三個數進行比較。
int tmp=0；
if(a<b){
tmp=a;

a=b;

b=tmp;

}
if(a<c){
tmp=a;

a=c;

c=tmp;
}
if(b<c){
tmp=b;

b=c;

c=tmp;
}
System.out.println(a+" "+b+" "+c);
這就可以了，自己想想動動腦子才能靈活運用，如果只是給你代碼，你只會復制粘貼。

Ⅲ Java排序一共有幾種

日常操作中，常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。

各類排序方法代碼如圖：

Ⅳ Java中冒泡排序和選擇排序有什麼不同

冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。
public class Paixu {
public static void main(String[] args) {
int [] a = {2,6,4,5,1,7,3};
int i = 0;
int j = 0;
int n = 0;
for(i= 0;i<a.length-1;i++){
for(j=0;j<a.length-i-1;j++){
if(a[j]>a[j+1]){
n = a[j];
a[j] = a[j+1];
a[j+1] = n;
}
}
}
for ( i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}
直接選擇排序(Straight Select Sorting) 也是一種簡單的排序方法，它的基本思想是：第一次從R[0]~R[n-1]中選取最小值，與R[0]交換，第二次從R{1}~R[n-1]中選取最小值，與R[1]交換，....， 第i次從R[i-1]~R[n-1]中選取最小值，與R[i-1]交換，.....，第n-1次從R[n-2]~R[n-1]中選取最小值，與R[n-2]交換,總共通過n-1次,得到一個按排序碼從小到大排列的有序序列.
public class Paixu {
public static void main(String[] args) {
int [] a = {2,6,4,5,1,7,3};
int i = 0;
int j = 0;
int n = 0;
for(i= 0;i<a.length;i++){
for(j=i+1;j<a.length;j++){
if(a[i]>a[j]){
n = a[i];
a[j] = a[i];
a[i] = n;
}
}
}
for ( i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}

Ⅳ Java的排序演算法有哪些

排序： 插入，冒泡，選擇，Shell,快速排序

Ⅵ java基礎 insert方法問題

20大進階架構專題每日送達

1.直接插入排序

經常碰到這樣一類排序問題：把新的數據插入到已經排好的數據列中。

• 將第一個數和第二個數排序，然後構成一個有序序列

• 將第三個數插入進去，構成一個新的有序序列。

• 對第四個數、第五個數……直到最後一個數，重復第二步。

如何寫成代碼：


• 首先設定插入次數，即循環次數，for(int i=1;i

• 設定插入數和得到已經排好序列的最後一個數的位數。insertNum和j=i-1。

• 從最後一個數開始向前循環，如果插入數小於當前數，就將當前數向後移動一位。

• 將當前數放置到空著的位置，即j+1。

代碼實現如下：

public void insertSort(int[] a){
int length=a.length;//數組長度，將這個提取出來是為了提高速度。
int insertNum;//要插入的數
for(int i=1;i//插入的次數
insertNum=a[i];//要插入的數
int j=i-1;//已經排序好的序列元素個數
while(j>=0&&a[j]>insertNum){//序列從後到前循環，將大於insertNum的數向後移動一格
a[j+1]=a[j];//元素移動一格
j--;
}
a[j+1]=insertNum;//將需要插入的數放在要插入的位置。
}
}


2.希爾排序

• 對於直接插入排序問題，數據量巨大時。

• 將數的個數設為n，取奇數k=n/2，將下標差值為k的數分為一組，構成有序序列。

• 再取k=k/2 ，將下標差值為k的書分為一組，構成有序序列。

• 重復第二步，直到k=1執行簡單插入排序。

如何寫成代碼：

• 首先確定分的組數。

• 然後對組中元素進行插入排序。

• 然後將length/2，重復1,2步，直到length=0為止。

代碼實現如下：

public void sheelSort(int[] a){
int d = a.length;
while (d!=0) {
d=d/2;
for (int x = 0; x < d; x++) {//分的組數
for (int i = x + d; i < a.length; i += d) {//組中的元素，從第二個數開始
int j = i - d;//j為有序序列最後一位的位數
int temp = a[i];//要插入的元素
for (; j >= 0 && temp < a[j]; j -= d) {//從後往前遍歷。
a[j + d] = a[j];//向後移動d位
}
a[j + d] = temp;
}
}
}
}


3.簡單選擇排序

• 常用於取序列中最大最小的幾個數時。

(如果每次比較都交換，那麼就是交換排序；如果每次比較完一個循環再交換，就是簡單選擇排序。)

• 遍歷整個序列，將最小的數放在最前面。

• 遍歷剩下的序列，將最小的數放在最前面。

• 重復第二步，直到只剩下一個數。

如何寫成代碼：


• 首先確定循環次數，並且記住當前數字和當前位置。

• 將當前位置後面所有的數與當前數字進行對比，小數賦值給key，並記住小數的位置。

• 比對完成後，將最小的值與第一個數的值交換。

• 重復2、3步。

代碼實現如下：

public void selectSort(int[] a) {
int length = a.length;
for (int i = 0; i < length; i++) {//循環次數
int key = a[i];
int position=i;
for (int j = i + 1; j < length; j++) {//選出最小的值和位置
if (a[j] < key) {
key = a[j];
position = j;
}
}
a[position]=a[i];//交換位置
a[i]=key;
}
}


4.堆排序

• 對簡單選擇排序的優化。

• 將序列構建成大頂堆。

• 將根節點與最後一個節點交換，然後斷開最後一個節點。

• 重復第一、二步，直到所有節點斷開。

代碼實現如下：


public void heapSort(int[] a){
System.out.println("開始排序");
int arrayLength=a.length;
//循環建堆
for(int i=0;i-1;i++){
//建堆

buildMaxHeap(a,arrayLength-1-i);
//交換堆頂和最後一個元素
swap(a,0,arrayLength-1-i);
System.out.println(Arrays.toString(a));
}
}
private void swap(int[] data, int i, int j) {
// TODO Auto-generated method stub
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
//對data數組從0到lastIndex建大頂堆
private void buildMaxHeap(int[] data, int lastIndex) {
// TODO Auto-generated method stub
//從lastIndex處節點（最後一個節點）的父節點開始
for(int i=(lastIndex-1)/2;i>=0;i--){
//k保存正在判斷的節點
int k=i;
//如果當前k節點的子節點存在
while(k*2+1<=lastIndex){
//k節點的左子節點的索引
int biggerIndex=2*k+1;
//如果biggerIndex小於lastIndex，即biggerIndex+1代表的k節點的右子節點存在
if(biggerIndex //若果右子節點的值較大
if(data[biggerIndex]1]){
//biggerIndex總是記錄較大子節點的索引
biggerIndex++;
}
}
//如果k節點的值小於其較大的子節點的值
if(data[k] //交換他們
swap(data,k,biggerIndex);
//將biggerIndex賦予k，開始while循環的下一次循環，重新保證k節點的值大於其左右子節點的值
k=biggerIndex;
}else{
break;
}
}
}
}


5.冒泡排序

• 一般不用。

• 將序列中所有元素兩兩比較，將最大的放在最後面。

• 將剩餘序列中所有元素兩兩比較，將最大的放在最後面。

• 重復第二步，直到只剩下一個數。

如何寫成代碼：


• 設置循環次數。

• 設置開始比較的位數，和結束的位數。

• 兩兩比較，將最小的放到前面去。

• 重復2、3步，直到循環次數完畢。

代碼實現如下：

public void bubbleSort(int[] a){
int length=a.length;
int temp;
for(int i=0;i for(int j=0;j-1;j++){
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}


6.快速排序

• 要求時間最快時。

• 選擇第一個數為p，小於p的數放在左邊，大於p的數放在右邊。

• 遞歸的將p左邊和右邊的數都按照第一步進行，直到不能遞歸。

代碼實現如下：


public static void quickSort(int[] numbers, int start, int end) {
if (start < end) {
int base = numbers[start]; // 選定的基準值（第一個數值作為基準值）
int temp; // 記錄臨時中間值
int i = start, j = end;
do {
while ((numbers[i] < base) && (i < end))
i++;
while ((numbers[j] > base) && (j > start))
j--;
if (i <= j) {
temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
i++;
j--;
}
} while (i <= j);
if (start < j)
quickSort(numbers, start, j);
if (end > i)
quickSort(numbers, i, end);
}
}


7.歸並排序

• 速度僅次於快排，內存少的時候使用，可以進行並行計算的時候使用。

• 選擇相鄰兩個數組成一個有序序列。

• 選擇相鄰的兩個有序序列組成一個有序序列。

• 重復第二步，直到全部組成一個有序序列。

代碼實現如下：


public static void mergeSort(int[] numbers, int left, int right) {
int t = 1;// 每組元素個數
int size = right - left + 1;
while (t < size) {
int s = t;// 本次循環每組元素個數
t = 2 * s;
int i = left;
while (i + (t - 1) < size) {
merge(numbers, i, i + (s - 1), i + (t - 1));
i += t;
}
if (i + (s - 1) < right)
merge(numbers, i, i + (s - 1), right);
}
}
private static void merge(int[] data, int p, int q, int r) {
int[] B = new int[data.length];
int s = p;
int t = q + 1;
int k = p;
while (s <= q && t <= r) {
if (data[s] <= data[t]) {
B[k] = data[s];
s++;
} else {
B[k] = data[t];
t++;
}
k++;
}
if (s == q + 1)
B[k++] = data[t++];
else
B[k++] = data[s++];
for (int i = p; i <= r; i++)
data[i] = B[i];
}


8.基數排序

• 用於大量數，很長的數進行排序時。

• 將所有的數的個位數取出，按照個位數進行排序，構成一個序列。

• 將新構成的所有的數的十位數取出，按照十位數進行排序，構成一個序列。

代碼實現如下：


public void sort(int[] array) {
//首先確定排序的趟數;
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
int time = 0;
//判斷位數;
while (max > 0) {
max /= 10;
time++;
}
//建立10個隊列;
List queue = new ArrayList ();
for ( int i = 0; i < 10; i++) {
ArrayList queue1 = new ArrayList ();
queue.add(queue1);
}
//進行time次分配和收集;
for ( int i = 0; i < time; i++) {
//分配數組元素;
for ( int j = 0; j < array.length; j++) {
//得到數字的第time+1位數;
int x = array[j] % ( int) Math. pow( 10, i + 1) / ( int) Math. pow( 10, i);
ArrayList queue2 = queue.get(x);
queue2.add( array[j]);
queue. set(x, queue2);
}
int count = 0; //元素計數器;
//收集隊列元素;
for ( int k = 0; k < 10; k++) {
while ( queue.get(k).size() > 0) {
ArrayList queue3 = queue.get(k);
array[count] = queue3.get( 0);
queue3.remove( 0);
count++;
}
}
}
}

來源：KaelQ

地址：www.jianshu.com/p/5e171281a387

獲取方式：點「在看」，V信關注師長的小號：編程最前線並回復面試領取，更多精彩陸續奉上。

Ⅶ 請給出java幾種排序方法

java常見的排序分為：
1 插入類排序
主要就是對於一個已經有序的序列中，插入一個新的記錄。它包括：直接插入排序，折半插入排序和希爾排序
2 交換類排序
這類排序的核心就是每次比較都要「交換」，在每一趟排序都會兩兩發生一系列的「交換」排序，但是每一趟排序都會讓一個記錄排序到它的最終位置上。它包括：起泡排序，快速排序
3 選擇類排序
每一趟排序都從一系列數據中選擇一個最大或最小的記錄，將它放置到第一個或最後一個為位置交換，只有在選擇後才交換，比起交換類排序，減少了交換記錄的時間。屬於它的排序：簡單選擇排序，堆排序
4 歸並類排序
將兩個或兩個以上的有序序列合並成一個新的序列
5 基數排序
主要基於多個關鍵字排序的。
下面針對上面所述的演算法，講解一些常用的java代碼寫的演算法
二 插入類排序之直接插入排序
直接插入排序,一般對於已經有序的隊列排序效果好。
基本思想：每趟將一個待排序的關鍵字按照大小插入到已經排序好的位置上。
演算法思路，從後往前先找到要插入的位置，如果小於則就交換，將元素向後移動，將要插入數據插入該位置即可。時間復雜度為O(n2),空間復雜度為O(1)
package sort.algorithm;
public class DirectInsertSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
int temp, j;
for (int i = 1; i < data.length; i++) {
temp = data[i];
j = i - 1;
// 每次比較都是對於已經有序的
while (j >= 0 && data[j] > temp) {
data[j + 1] = data[j];
j--;
}
data[j + 1] = temp;
}
// 輸出排序好的數據
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}
三 插入類排序之折半插入排序(二分法排序)
條件：在一個已經有序的隊列中，插入一個新的元素
折半插入排序記錄的比較次數與初始序列無關
思想：折半插入就是首先將隊列中取最小位置low和最大位置high，然後算出中間位置mid
將中間位置mid與待插入的數據data進行比較，
如果mid大於data，則就表示插入的數據在mid的左邊，high=mid-1;
如果mid小於data，則就表示插入的數據在mid的右邊,low=mid+1
最後整體進行右移操作。
時間復雜度O(n2),空間復雜度O(1)

package sort.algorithm;
//折半插入排序
public class HalfInsertSort {
public static void main(String[] args) {
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
// 存放臨時要插入的元素數據
int temp;
int low, mid, high;
for (int i = 1; i < data.length; i++) {
temp = data[i];
// 在待插入排序的序號之前進行折半插入
low = 0;
high = i - 1;
while (low <= high) {
mid = (low + high) / 2;
if (temp < data[mid])
high = mid - 1;
else
// low=high的時候也就是找到了要插入的位置，
// 此時進入循環中，將low加1，則就是要插入的位置了
low = mid + 1;
}
// 找到了要插入的位置，從該位置一直到插入數據的位置之間數據向後移動
for (int j = i; j >= low + 1; j--)
data[j] = data[j - 1];
// low已經代表了要插入的位置了
data[low] = temp;
}
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}

四 插入類排序之希爾排序
希爾排序，也叫縮小增量排序，目的就是盡可能的減少交換次數，每一個組內最後都是有序的。
將待續按照某一種規則分為幾個子序列，不斷縮小規則，最後用一個直接插入排序合成
空間復雜度為O(1)，時間復雜度為O(nlog2n)
演算法先將要排序的一組數按某個增量d（n/2,n為要排序數的個數）分成若干組，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序後，排序完成。

package sort.algorithm;
public class ShellSort {
public static void main(String[] args) {
int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };
double d1 = a.length;
int temp = 0;
while (true)
{
//利用這個在將組內倍數減小
//這里依次為5,3,2,1
d1 = Math.ceil(d1 / 2);
//d為增量每個分組之間索引的增量
int d = (int) d1;
//每個分組內部排序
for (int x = 0; x < d; x++)
{
//組內利用直接插入排序
for (int i = x + d; i < a.length; i += d) {
int j = i - d;
temp = a[i];
for (; j >= 0 && temp < a[j]; j -= d) {
a[j + d] = a[j];
}
a[j + d] = temp;
}
}

if (d == 1)
break;
}
for (int i = 0; i < a.length; i++)
System.out.print(a[i]+" ");
}
}

五 交換類排序之冒泡排序
交換類排序核心就是每次比較都要進行交換
冒泡排序：是一種交換排序
每一趟比較相鄰的元素，較若大小不同則就會發生交換，每一趟排序都能將一個元素放到它最終的位置！每一趟就進行比較。
時間復雜度O(n2)，空間復雜度O(1)

package sort.algorithm;
//冒泡排序：是一種交換排序
public class BubbleSort {
// 按照遞增順序排序
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };
int temp = 0;
// 排序的比較趟數,每一趟都會將剩餘最大數放在最後面
for (int i = 0; i < data.length - 1; i++) {
// 每一趟從開始進行比較，將該元素與其餘的元素進行比較
for (int j = 0; j < data.length - 1; j++) {
if (data[j] > data[j + 1]) {
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
for (int i = 0; i < data.length; i++)
System.out.print(data[i] + " ");
}
}

Ⅷ java中基數排序演算法代碼

/**
*冒泡法排序<br/>

*<li>比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。</li>
*<li>對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。</li>
*<li>針對所有的元素重復以上的步驟，除了最後一個。</li>
*<li>持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。</li>

*
*@paramnumbers
*需要排序的整型數組
*/
publicstaticvoidbubbleSort(int[]numbers){
inttemp;//記錄臨時中間值
intsize=numbers.length;//數組大小
for(inti=0;i<size-1;i++){
for(intj=i+1;j<size;j++){
if(numbers[i]<numbers[j]){//交換兩數的位置
temp=numbers[i];
numbers[i]=numbers[j];
numbers[j]=temp;
}
}
}
}

Ⅸ 數據結構裡面的「基數排序」到底是什麼

基數排序的方式可以採用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由鍵值的最右邊開始，而MSD則相反，由鍵值的最左邊開始。 以LSD為例，假設原來有一串數值如下所示： 73, 22, 93, 43, 55, 14, 28, 65, 39, 81 首先根據個位數的數值，在走訪數值時將它們分配至編號0到9的桶子中： 0 1 81 2 22 3 73 93 43 4 14 5 55 65 6 7 8 28 9 39 接下來將這些桶子中的數值重新串接起來，成為以下的數列： 81, 22, 73, 93, 43, 14, 55, 65, 28, 39 接著再進行一次分配，這次是根據十位數來分配： 0 1 14 2 22 28 3 39 4 43 5 55 6 65 7 73 8 81 9 93 接下來將這些桶子中的數值重新串接起來，成為以下的數列： 14, 22, 28, 39, 43, 55, 65, 73, 81, 93 這時候整個數列已經排序完畢；如果排序的對象有三位數以上，則持續進行以上的動作直至最高位數為止。 LSD的基數排序適用於位數小的數列，如果位數多的話，使用MSD的效率會比較好，MSD的方式恰與LSD相反，是由高位數為基底開始進行分配，其他的演算方式則都相同。
編輯本段效率分析
時間效率：設待排序列為n個記錄，d個關鍵碼，關鍵碼的取值范圍為radix，則進行鏈式基數排序的時間復雜度為O(d(n+radix))，其中，一趟分配時間復雜度為O(n)，一趟收集時間復雜度為O(n)，共進行d趟分配和收集。 空間效率：需要2*radix個指向隊列的輔助空間，以及用於靜態鏈表的n個指針。
編輯本段實現方法
最高位優先(Most Significant Digit first)法，簡稱MSD法：先按k1排序分組，同一組中記錄，關鍵碼k1相等，再對各組按k2排序分成子組，之後，對後面的關鍵碼繼續這樣的排序分組，直到按最次位關鍵碼kd對各子組排序後。再將各組連接起來，便得到一個有序序列。 最低位優先(Least Significant Digit first)法，簡稱LSD法：先從kd開始排序，再對kd-1進行排序，依次重復，直到對k1排序後便得到一個有序序列。
編輯本段實現
* C
#include <stdio.h> #include <stdlib.h> int main(){ int data[10]={73,22,93,43,55,14,28,65,39,81}; int temp[10][10]={0}; 基數排序演算法
int order[10]={0}; int i,j,k,n,lsd; k=0;n=1; printf("\n排序前: "); for (i=0;i<10;i++) printf("%d ",data[i]); putchar('\n'); while (n<=10){ for (i=0;i<10;i++){ lsd=((data[i]/n)%10); temp[lsd][order[lsd]]=data[i]; order[lsd]++; } printf("\n重新排列: "); for (i=0;i<10;i++){ if(order[i]!=0) for (j=0;j<order[i];j++){ data[k]=temp[i][j]; printf("%d ",data[k]); k++; } order[i]=0; } n*=10; k=0; } putchar('\n'); printf("\n排序後: "); for (i=0;i<10;i++) printf("%d ",data[i]); return 0; }
* Java
public class RadixSort { public static void sort(int[] number, int d) { int k=0; int n=1; int m=1; int[][] temp = new int[number.length][number.length]; int[] order = new int[number.length]; while(m <= d) { for(int i = 0; i < number.length; i++) { int lsd = ((number[i] / n) % 10); temp[lsd][order[lsd]] = number[i]; order[lsd]++; } for(int i = 0; i < d; i++) { if(order[i] != 0) for(int j = 0; j < order[i]; j++) { number[k] = temp[i][j]; k++; } order[i] = 0; } n *= 10; k = 0; m++; } } public static void main(String[] args) { int[] data = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100}; RadixSort.sort(data, 10); for(int i = 0; i < data.length; i++) { System.out.print(data[i] + " "); } }
* pascal
program jspx; const n=8; type link=^node; node=record data:integer; next:link; end; var i,j,l,m,k:integer; a:array[1..n] of integer; s:string; q,head:array[0..9] of link; p,p1:link; begin writeln('Enter data:'); for i:=1 to n do read(a[i]); for i:=5 downto 1 do begin for j:=0 to 9 do begin new(head[j]); head[j]^.next:=nil; q[j]:=head[j] end; for j:=1 to n do begin str(a[j],s); for k:=1 to 5-length(s) do s:='0'+ s; m:=ord(s[i])-48; new(p); p^.data:=a[j]; p^.next:=nil; q[m]^.next:=p; q[m]:=p; end; l:=0; for j:=0 to 9 do begin p:=head[j]; while p^.next<>nil do begin l:=l+1;p1:=p;p:=p^.next;dispose(p1);a[l]:=p^.data; end; end; end; writeln('Sorted data:'); for i:= 1 to n do write(a[i]:6); end.
編輯本段c++實現基數排序
int maxbit(int data[],int n) //輔助函數，求數據的最大位數 { int d = 1; //保存最大的位數 int p =10; for(int i = 0;i < n; ++i) { while(data[i] >= p) { p *= 10; ++d; } } return d; } void radixsort(int data[],int n) //基數排序 { int d = maxbit(data,n); int * tmp = new int[n]; int * count = new int[10]; //計數器 int i,j,k; int radix = 1; for(i = 1; i<= d;i++) //進行d次排序 { for(j = 0;j < 10;j++) count[j] = 0; //每次分配前清空計數器 for(j = 0;j < n; j++) { k = (data[j]/radix)%10; //統計每個桶中的記錄數 count[k]++; } for(j = 1;j < 10;j++) count[j] = count[j-1] + count[j]; //將tmp中的位置依次分配給每個桶 for(j = n-1;j >= 0;j--) //將所有桶中記錄依次收集到tmp中 { k = (data[j]/radix)%10; count[k]--; tmp[count[k]] = data[j]; } for(j = 0;j < n;j++) //將臨時數組的內容復制到data中 data[j] = tmp[j]; radix = radix*10; } delete [] tmp; delete [] count; } C# 實現基數排序 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace LearnSort { class Program { static void Main(string[] args) { int[] arr = CreateRandomArray(10);//產生隨機數組 Print(arr);//輸出數組 RadixSort(ref arr);//排序 Print(arr);//輸出排序後的結果 Console.ReadKey(); } public static void RadixSort(ref int[] arr) { int iMaxLength = GetMaxLength(arr); RadixSort(ref arr, iMaxLength); } //排序 private static void RadixSort(ref int[] arr, int iMaxLength) { List<int> list = new List<int>();//存放每次排序後的元素 List<int>[] listArr = new List<int>[10];//十個桶 char currnetChar;//存放當前的字元 比如說 某個元素123 中的2 string currentItem;//存放當前的元素 比如說 某個元素123 for (int i = 0; i < listArr.Length; i++)//給十個桶分配內存初始化。 listArr[i] = new List<int>(); for (int i = 0; i < iMaxLength; i++)//一共執行iMaxLength次，iMaxLength是元素的最大位數。 { foreach (int number in arr)//分桶 { currentItem = number.ToString();//將當前元素轉化成字元串 try { currnetChar = currentItem[currentItem.Length-i-1]; }//從個位向高位開始分桶 catch { listArr[0].Add(number); continue; }//如果發生異常，則將該數壓入listArr[0]。比如說5 是沒有十位數的，執行上面的操作肯定會發生越界異常的，這正是期望的行為，我們認為5的十位數是0，所以將它壓入listArr[0]的桶里。 switch (currnetChar)//通過currnetChar的值，確定它壓人哪個桶中。 { case '0': listArr[0].Add(number); break; case '1': listArr[1].Add(number); break; case '2': listArr[2].Add(number); break; case '3': listArr[3].Add(number); break; case '4': listArr[4].Add(number); break; case '5': listArr[5].Add(number); break; case '6': listArr[6].Add(number); break; case '7': listArr[7].Add(number); break; case '8': listArr[8].Add(number); break; case '9': listArr[9].Add(number); break; default: throw new Exception("unknow error"); } } for (int j = 0; j < listArr.Length; j++)//將十個桶里的數據重新排列，壓入list foreach (int number in listArr[j].ToArray<int>()) { list.Add(number); listArr[j].Clear();//清空每個桶 } arr = list.ToArray<int>();//arr指向重新排列的元素 //Console.Write("{0} times:",i); Print(arr);//輸出一次排列的結果 list.Clear();//清空list } } //得到最大元素的位數 private static int GetMaxLength(int[] arr) { int iMaxNumber = Int32.MinValue; foreach (int i in arr)//遍歷得到最大值 { if (i > iMaxNumber) iMaxNumber = i; } return iMaxNumber.ToString().Length;//這樣獲得最大元素的位數是不是有點投機取巧了... } //輸出數組元素 public static void Print(int[] arr) { foreach (int i in arr) System.Console.Write(i.ToString()+'\t'); System.Console.WriteLine(); } //產生隨機數組。隨機數的范圍是0到1000。 參數iLength指產生多少個隨機數 public static int[] CreateRandomArray(int iLength) { int[] arr = new int[iLength]; Random random = new Random(); for (int i = 0; i < iLength; i++) arr[i] = random.Next(0,1001); return arr; } } }

Ⅹ JAVA里的排序（演算法）,最後順序很亂吶。。

給你個例子：
public class RadixSort {
public static void sort(int[] number, int d) {
int k=0;
int n=1;
int m=1;
int[][] temp = new int[number.length][number.length];
int[] order = new int[number.length];
while(m <= d) {
for(int i = 0; i < number.length; i++) {
int lsd = ((number[i] / n) % 10);
temp[lsd][order[lsd]] = number[i];
order[lsd]++;
}
for(int i = 0; i < d; i++) {
if(order[i] != 0)
for(int j = 0; j < order[i]; j++) {
number[k] = temp[i][j];
k++;
}
order[i] = 0;
}
n *= 10;
k = 0;
m++;
}
}
public static void main(String[] args) {
int[] data =
{73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100};
RadixSort.sort(data, 10);
for(int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
}