就自己簡單的理解了一些排序算法（JAVA）思路和代碼分享給大家：歡迎大家進行交流。

直接插入排序，折半插入排序，冒泡排序，快速排序

 1 public class Sort {
 2     /*
 3      * 直接插入排序： 先確定一個有序數組，然後把插入的數與有序數組從最後依次進行比較， 直到插入的數比有序數組的數大，此數換為插入的數字，從此位置以後
 4      * 的數依次向後移動一位。
 5      */
 6     public static void insert(int[] a) {
 7         for (int i = 1; i < a.length; i++) {
 
 8             int b = a[i], j;
 9             for (j = i - 1; j >= 0 && b < a[j]; j--) {
10                 a[j + 1] = a[j];
11             }
12             a[j + 1] = b;
13 
14         }
15     }
16 
17     /*
18      * 折半插入排序法： 對有序數組確定最小下標，最大下標， 然後將插入的值與中間值進行比較，
19      * 如果小於中間值，則最大下標為中間下標-1，否則最小下標為中間下標+1; 循環確定插入位置為最小下標，然後把插入的數字賦值給最小下標對應
 
20      * 的數，後面的數依次往後移動一位。
21      */
22     public static void halfInsert(int[] a) {
23         for (int i = 1; i < a.length; i++) {
24             int b = a[i], low = 0, high = i - 1;
25             while (low <= high) {
26                 int mid = (low + high) / 2;
27                 if (b > a[mid]) {
 
28                     low = mid + 1;
29                 } else {
30                     high = mid - 1;
31                 }
32             }
33 
34             for (int j = low; j < i; j++) {
35                 a[j + 1] = a[j];
36             }
37             a[low] = b;
38         }
39 
40     }
41 
42     /*
43      * 冒泡排序： 雙重循環，最多進行n-1趟排序，每相鄰兩個數進行比較，如果前面的大，則進行交換，
44      * 用exchange判斷兩數是否變換了，如果沒有變換，則不必再進行上述步驟進行排序，直接輸出結果。
45      */
46     public static void bubblseSort(int[] a) {
47         boolean exchange = true;// 是否交換的標誌
48         for (int i = 1; i < a.length && exchange; i++) {
49             exchange = false;
50             for (int j = 0; j < a.length - 1; j++) {
51                 if (a[j + 1] < a[j]) {
52                     int b = a[j + 1];
53                     a[j + 1] = a[j];
54                     a[j] = b;
55                     exchange = true;
56                 }
57             }
58 
59         }
60     }
61 /*
62  * 快速排序算法：
63  * 找第一個數做基準量，從後往前找，比基準量大的數放到後邊，小的就把數往前移動，
64  * 從前往後找，比基準量小的放到前面，大的就往後移動，
65  * 循環執行上述步驟，直到前後端序列都變為1個數為止，用遞歸算法實現。
66  */
67     public static void quickSort(int[] a, int b, int e) {
68         int i = b, j = e, x = a[i];
69         while (i < j) {
70             while (i < j && x < a[j])
71                 j--;
72             if (i < j)
73                 a[i++] = a[j]; // 後端小的數向前移動
74             while (i < j && x > a[i])
75                 i++;
76             if (i < j)
77                 a[j--] = a[i]; // 前端大的數向後移動
78 
79         }
80         ;
81         // 此時，i=j;
82         a[i] = x;
83         if (b < i)
84             quickSort(a, b, i - 1);
85         if (i < e)
86             quickSort(a, i + 1, e);
87     }
88 }

多種排序算法的思路和簡單代碼的實現（一）