一。冒泡排序：

實現思想：

重復地走訪過要排序的元素列，一次比較兩個相鄰的元素，如果他們的順序(如從大到小、首字母從A到Z)錯誤就把他們交換過來。走訪元素的工作是重復地進行直到沒有相鄰元素需要交換，也就是說該元素已經排序完成。

代碼：

1 packageNumSort;2

3 //冒泡排序

4 public classBubbleSort {5 public static voidmain(String[] args){6 int num[] ={23,1,56,78,5,43,34,34,78,9,99};7 int n =num.length;8 inttemp;9 for(int i=0;inum[j+1]){12 temp = num[j+1];13 num[j+1] =num[j];14 num[j] =temp;15 }16 }17 }18 for(int i=0;i

二。桶排序：

實現思想：

桶排序 (Bucket sort)或所謂的箱排序，工作的原理是將數組分到有限數量的桶子里。每個桶子再個別排序。

代碼：

1 packageNumSort;2

3 //桶排序

4 public classBucketSort {5 public static voidmain(String[] args){6 int num[] ={23,1,56,78,5,43,34,34,78,9,99};7 int[] a = new int[100];8 for(int i=0;i<100;i++){9 a[i] = 0;10 }11 for(int i=0;i0){16 for(int j=0;j

三。選擇排序：

實現思想：

選擇排序(Selection sort)是一種簡單直觀的排序算法。它的工作原理是每一次從待排序的數據元素中選出最小(或最大)的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法。

代碼：

1 packageNumSort;2

3 //選擇排序

4 public classSelectSort {5 public static voidmain(String[] args){6 int num[] ={23,1,56,78,5,43,34,34,78,9,99};7 int n =num.length;8 inttemp;9 for(int i=0;inum[j]){12 temp =num[i];13 num[i] =num[j];14 num[j] =temp;15 }16 }17 }18 for(int i=0;i

四。快速排序：

實現思想：

通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

代碼：

1 packageNumSort;2

3 importjava.util.Arrays;4

5 public classQuickSort2 {6 public static voidmain(String[] args){7 int num[] = {23,5,67,98,76,2,1,5,65,23,34};8 quickS(num,0,num.length-1);9 System.out.println(Arrays.toString(num));10 }11 public static void quickS(int num[],int left,intright){12 int i =left;13 int j =right;14 inttemp;15 int middle =num[left];16 if(left>=right){17 return;18 }19 while(i!=j){20 while(num[j]>middle&&i

五。歸并排序：

實現思想：

歸并排序(MERGE-SORT)是建立在歸并操作上的一種有效的排序算法,該算法是采用分治法(Divide and Conquer)的一個非常典型的應用。將已有序的子序列合并，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合并成一個有序表，稱為二路歸并。

代碼：

1 packageNumSort;2

3 importjava.util.Arrays;4

5 public classMergeSort {6 public static voidmain(String[] args){7 int num[] = {34,5,23,123,8,76,98,65,34,65,99};8 MergeS(num,0,num.length-1);9 System.out.println(Arrays.toString(num));10 }11 public static void Merge(int num[],int low,int middle,inthigh){12 int i =low;13 int j = middle+1;14 int k = 0;15 int B[] = new int[high-low+1];16 while(i<=middle&&j<=high){17 if(num[i]<=num[j]){18 B[k] =num[i];19 k++;20 i++;21 }22 else{23 B[k] =num[j];24 k++;25 j++;26 }27 }28 while(i<=middle){29 B[k++] = num[i++];30 }31 while(j<=high){32 B[k++] = num[j++];33 }34 //System.arraycopy(B, 0, num, 0, num.length);

35 for(int l=0;l

六。希爾排序：

先取一個小于n的整數d1作為第一個增量，把文件的全部記錄分組。所有距離為d1的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然后，取第二個增量d2

?=1(

?

?…

七。堆排序：

堆排序(Heapsort)是指利用堆積樹(堆)這種數據結構所設計的一種排序算法，它是選擇排序的一種。可以利用數組的特點快速定位指定索引的元素。堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節點的值都不大于其父節點的值，即A[PARENT[i]] >= A[i]。在數組的非降序排序中，需要使用的就是大根堆，因為根據大根堆的要求可知，最大的值一定在堆頂。

八。基數排序：

第一步(來自百度百科)

以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相反，是由高位數為基底開始進行分配，但在分配之后并不馬上合并回一個數組中，而是在每個“桶子”中建立“子桶”，將每個桶子中的數值按照下一數位的值分配到“子桶”中。在進行完最低位數的分配后再合并回單一的數組中。

九。各排序算法比較：

圖片來自網絡：

總結

以上是生活随笔為你收集整理的java 比较算法_JAVA排序算法实现和比较：冒泡，桶，选择，快排，归并的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。