1.直接插入排序

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

1. 將第一個數和第二個數排序，然後構成一個有序序列
2. 將第三個數插入進去，構成一個新的有序序列。
3. 對第四個數、第五個數……直到最後一個數，重複第二步。

如何寫寫成程式碼：

1. 首先設定插入次數，即迴圈次數，for(int i=1;i<length;i++)，1個數的那次不用插入。
2. 設定插入數和得到已經排好序列的最後一個數的位數。insertNum和j=i-1。
3. 從最後一個數開始向前迴圈，如果插入數小於當前數，就將當前數向後移動一位。
4. 將當前數放置到空著的位置，即j+1。

程式碼實現如下：

1. publicvoid insertSort(int[] a){  
2.         int length=a.length;//陣列長度，將這個提取出來是為了提高速度。int insertNum;//要插入的數for(int i=1;i<length;i++){//插入的次數
3.             insertNum=a[i];//要插入的數int j=i-1;//已經排序好的序列元素個數while(j>=0&&a[j]>insertNum){//序列從後到前迴圈，將大於insertNum的數向後移動一格
4.                 a[j+1
   ]=a[j];//元素移動一格
5.                 j--;  
6.             }  
7.             a[j+1]=insertNum;//將需要插入的數放在要插入的位置。
8.         }  
9.     }  

2.希爾排序

對於直接插入排序問題，資料量巨大時。

1. 將數的個數設為n，取奇數k=n/2，將下標差值為k的書分為一組，構成有序序列。
2. 再取k=k/2 ，將下標差值為k的書分為一組，構成有序序列。
3. 重複第二步，直到k=1執行簡單插入排序。

如何寫成程式碼：

1. 首先確定分的組數。
2. 然後對組中元素進行插入排序。
3. 然後將length/2，重複1,2步，直到length=0為止。

程式碼實現如下：

1. publicvoid sheelSort(int[] a){  
2.         int d  = a.length;  
3.         while (d!=0) {  
4.             d=d/2;  
5.             for (int x = 0; x < d; x++) {//分的組數
6.                 for (int i = x + d; i < a.length; i += d) {//組中的元素，從第二個數開始
7.                     int j = i - d;//j為有序序列最後一位的位數
8.                     int temp = a[i];//要插入的元素
9.                     for (; j >= 0 && temp < a[j]; j -= d) {//從後往前遍歷。
10.                         a[j + d] = a[j];//向後移動d位
11.                     }  
12.                     a[j + d] = temp;  
13.                 }  
14.             }  
15.         }  
16.     }  

3.簡單選擇排序

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

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

1. 遍歷整個序列，將最小的數放在最前面。
2. 遍歷剩下的序列，將最小的數放在最前面。
3. 重複第二步，直到只剩下一個數。

如何寫成程式碼：

1. 首先確定迴圈次數，並且記住當前數字和當前位置。
2. 將當前位置後面所有的數與當前數字進行對比，小數賦值給key，並記住小數的位置。
3. 比對完成後，將最小的值與第一個數的值交換。
4. 重複2、3步。

程式碼實現如下：

1. publicvoid selectSort(int[] a) {  
2.        int length = a.length;  
3.        for (int i = 0; i < length; i++) {//迴圈次數
4.            int key = a[i];  
5.            int position=i;  
6.            for (int j = i + 1; j < length; j++) {//選出最小的值和位置
7.                if (a[j] < key) {  
8.                    key = a[j];  
9.                    position = j;  
10.                }  
11.            }  
12.            a[position]=a[i];//交換位置
13.            a[i]=key;  
14.        }  
15.    }  

4.堆排序

對簡單選擇排序的優化。

1. 將序列構建成大頂堆。
2. 將根節點與最後一個節點交換，然後斷開最後一個節點。
3. 重複第一、二步，直到所有節點斷開。

1. publicvoid heapSort(int[] a){  
2.         System.out.println("開始排序");  
3.         int arrayLength=a.length;  
4.         //迴圈建堆  
5.         for(int i=0;i<arrayLength-1;i++){  
6.             //建堆  
7.             buildMaxHeap(a,arrayLength-1-i);  
8.             //交換堆頂和最後一個元素  
9.             swap(a,0,arrayLength-1-i);  
10.             System.out.println(Arrays.toString(a));  
11.         }  
12.     }  
13.     privatevoid swap(int[] data, int i, int j) {  
14.         // TODO Auto-gene