排序演算法的使用可以讓我們更方便的進行排序，下面是小編給大家提供的Java常用的五大排序演算法大家可以參考閱讀，更多詳情請關注應屆畢業生考試網。
1、Java排序演算法之選擇排序
選擇排序的基本思想是遍歷陣列的過程中，以 i 代表當前需要排序的序號，則需要在剩餘的 [i…n-1] 中找出其中的最小值，然後將找到的最小值與 i 指向的值進行交換。因為每一趟確定元素的過程中都會有一個選擇最大值的子流程，所以人們形象地稱之為選擇排序。
舉個例項來看看：
1.初始： [38, 17, 16, 16, 7, 31, 39, 32, 2, 11]
2.3.i = 0: [2 , 17, 16, 16, 7, 31, 39, 32, 38 , 11] (0th [38]<->8th [2])
4.5.i = 1: [2, 7 , 16, 16, 17 , 31, 39, 32, 38, 11] (1st [38]<->4th [17])
6.7.i = 2: [2, 7, 11 , 16, 17, 31, 39, 32, 38, 16 ] (2nd [11]<->9th [16])
8.9.i = 3: [2, 7, 11, 16, 17, 31, 39, 32, 38, 16] ( 無需交換 )
10.11.i = 4: [2, 7, 11, 16, 16 , 31, 39, 32, 38, 17 ] (4th [17]<->9th [16])
12.13.i = 5: [2, 7, 11, 16, 16, 17 , 39, 32, 38, 31 ] (5th [31]<->9th [17])
14.15.i = 6: [2, 7, 11, 16, 16, 17, 31 , 32, 38, 39 ] (6th [39]<->9th [31])
16.17.i = 7: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 無需交換 )
18.19.i = 8: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 無需交換 )
20.21.i = 9: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 無需交換 )
由例子可以看出，選擇排序隨著排序的進行( i 逐漸增大)，比較的次數會越來越少，但是不論陣列初始是否有序，選擇排序都會從 i 至陣列末尾進行一次選擇比較，所以給定長度的陣列，選擇排序的比較次數是固定的： 1 + 2 + 3 + … + n = n * (n + 1) / 2 ,而交換的次數則跟初始陣列的順序有關，如果初始陣列順序為隨機，則在最壞情況下，陣列元素將會交換 n 次，最好的情況下則可能 0 次(陣列本身即為有序)。
由此可以推出，選擇排序的時間複雜度和空間複雜度分別為 O(n2 )和 O(1)(選擇排序只需要一個額外空間用於陣列元素交換)。
實現程式碼：
1./**
2. * Selection Sorting
3. */
CTION(new Sortable() {
5. public
6. int len = th;
7. for (int i = 0; i < len; i++) {
8. int selected = i;
9. for (int j = i + 1; j < len; j++) {
10. int compare = array[j]areTo(array[selected]);
11. if (compare != 0 && compare < 0 == ascend) {
12. selected = j;
13. }
14. }
15.16. exchange(array, i, selected);
17. }
18. }
19.})
2、Java排序演算法之插入排序
插入排序的基本思想是在遍歷陣列的過程中，假設在序號 i 之前的元素即 [0i-1] 都已經排好序，本趟需要找到 i 對應的元素 x 的正確位置 k ,並且在尋找這個位置 k 的過程中逐個將比較過的元素往後移一位，為元素 x "騰位置",最後將 k 對應的元素值賦為 x ,插入排序也是根據排序的特性來命名的。
以下是一個例項，紅色 標記的數字為插入的數字，被劃掉的數字是未參與此次排序的元素，紅色 標記的數字與被劃掉數字之間的元素為逐個向後移動的元素，比如第二趟參與排序的元素為 [11, 31, 12] ,需要插入的元素為 12 ,但是 12 當前並沒有處於正確的位置，於是我們需要依次與前面的元素 31 、 11 做比較，一邊比較一邊移動比較過的元素，直到找到第一個比 12 小的元素 11 時停止比較，此時 31 對應的索引 1 則是 12 需要插入的位置。
1.初始： [11, 31, 12, 5, 34, 30, 26, 38, 36, 18]
2.3.第一趟： [11, 31 , 12, 5, 34, 30, 26, 38, 36, 18] (無移動的元素)
4.5.第二趟： [11, 12 , 31, 5, 34, 30, 26, 38, 36, 18] ( 31 向後移動)
6.7.第三趟： [5 , 11, 12, 31, 34, 30, 26, 38, 36, 18] ( 11, 12, 31 皆向後移動)
8.9.第四趟： [5, 11, 12, 31, 34 , 30, 26, 38, 36, 18] (無移動的元素)
10.11.第五趟： [5, 11, 12, 30 , 31, 34, 26, 38, 36, 18] ( 31, 34 向後移動)
12.13.第六趟： [5, 11, 12, 26 , 30, 31, 34, 38, 36, 18] ( 30, 31, 34 向後移動)
14.15.第七趟： [5, 11, 12, 26, 30, 31, 34, 38 , 36, 18] (無移動的元素)
16.17.第八趟： [5, 11, 12, 26, 30, 31, 34, 36 , 38, 18] ( 38 向後移動)
18.19.第九趟： [5, 11, 12, 18 , 26, 30, 31, 34, 36, 38] ( 26, 30, 31, 34, 36, 38 向後移動)
插入排序會優於選擇排序，理由是它在排序過程中能夠利用前部分數組元素已經排好序的一個優勢，有效地減少一些比較的次數，當然這種優勢得看陣列的初始順序如何，最壞的情況下(給定的陣列恰好為倒序)插入排序需要比較和移動的次數將會等於 1 + 2 + 3… + n = n * (n + 1) / 2 ,這種極端情況下，插入排序的效率甚至比選擇排序更差。因此插入排序是一個不穩定的排序方法，插入效率與陣列初始順序息息相關。一般情況下，插入排序的時間複雜度和空間複雜度分別為 O(n2 ) 和 O(1) .
實現程式碼：
1./**
2. * Insertion Sorting
3. */
RTION(new Sortable() {
5. public
6. int len = th;
7. for (int i = 1; i < len; i++) {
8. T toInsert = array[i];
9. int j = i;
10. for (; j > 0; j--) {
11. int compare = array[j - 1]areTo(toInsert);
12. if (compare == 0 || compare < 0 == ascend) {
13. break;
14. }
15. array[j] = array[j - 1];
16. }
17.
18. array[j] = toInsert;
19. }
20. }
21.})
3、Java排序演算法之氣泡排序
氣泡排序可以算是最經典的排序演算法了，記得小弟上學時最先接觸的也就是這個演算法了，因為實現方法最簡單，兩層 for 迴圈，裡層迴圈中判斷相鄰兩個元素是否逆序，是的話將兩個元素交換，外層迴圈一次，就能將陣列中剩下的元素中最小的元素"浮"到最前面，所以稱之為氣泡排序。
照例舉個簡單的例項吧：
1.
2.
3.初始狀態： [24, 19, 26, 39, 36, 7, 31, 29, 38, 23]
4.
5.內層第一趟： [24, 19, 26, 39, 36, 7, 31, 29, 23 , 38 ] ( 9th [23]<->8th [38 )
6.
7.內層第二趟： [24, 19, 26, 39, 36, 7, 31, 23 , 29 , 38] ( 8th [23]<->7th [29] )
8.
9.內層第三趟： [24, 19, 26, 39, 36, 7, 23 , 31 , 29, 38] ( 7th [23]<->6th [31] )
10.
11.內層第四趟： [24, 19, 26, 39, 36, 7, 23, 31, 29, 38] ( 7 、 23 都位於正確的順序，無需交換)
12.
13.內層第五趟： [24, 19, 26, 39, 7 , 36 , 23, 31, 29, 38] ( 5th [7]<->4th [36] )
14.
15.內層第六趟： [24, 19, 26, 7 , 39 , 36, 23, 31, 29, 38] ( 4th [7]<->3rd [39] )
16.
17.內層第七趟： [24, 19, 7 , 26 , 39, 36, 23, 31, 29, 38] ( 3rd [7]<->2nd [26] )
18.
19.內層第八趟： [24, 7 , 19 , 26, 39, 36, 23, 31, 29, 38] ( 2nd [7]<->1st [19] )
20.
21.內層第九趟： [7 , 24 , 19, 26, 39, 36, 23, 31, 29, 38] ( 1st [7]<->0th [24] )
22.
23.……
其實氣泡排序跟選擇排序比較相像，比較次數一樣，都為 n * (n + 1) / 2 ,但是氣泡排序在挑選最小值的過程中會進行額外的交換(氣泡排序在排序中只要發現相鄰元素的順序不對就會進行交換，與之對應的是選擇排序，只會在內層迴圈比較結束之後根據情況決定是否進行交換)，所以在我看來，選擇排序屬於氣泡排序的改進版。
實現程式碼：
1./**
2. * Bubble Sorting, it's very similar with Insertion Sorting
3. */
LE(new Sortable() {
5. public
6. int length = th;
7. int lastExchangedIdx = 0;
8. for (int i = 0; i < length; i++) {
9. // mark the flag to identity whether exchange happened to false
10. boolean isExchanged = false;
11. // last compare and exchange happened before reaching index i
12. int currOrderedIdx = lastExchangedIdx > i ? lastExchangedIdx : i;
13. for (int j = length - 1; j > currOrderedIdx; j--) {
14. int compare = array[j - 1]areTo(array[j]);
15. if (compare != 0 && compare > 0 == ascend) {
16. exchange(array, j - 1, j);
17. isExchanged = true;
18. lastExchangedIdx = j;
19. }
20. }
21. // if no exchange happen means array is already in order
22. if (isExchanged == false) {
