1. 冒泡算法
2. 快速排序
3. 歸並排序
4. 選擇排序
5. 堆排序

排序算法

重要性不言而喻，很多算法問題往往選擇一個好的排序算法往往問題可以迎刃而解

1、冒泡算法

冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。也就是雙重循環就可以搞定的問題但是需要註意下一邊界

算法步驟：

1）比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。

3）針對所有的元素重復以上的步驟，除了最後一個。

4）持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

 1 public void BubbleSort(int[] a) {
 2     int temp = 0;
 3     int len = a.length;
 4     for (int i = 0; i < len; i++) {
 5         for (int j = 1; j < len - i; j++)
 
 6             if (a[j - 1] > a[j]) {
 7                 //註意分清是a[j-1]還是a[j]不然容易出現邊界問題
 8                 // 從小到大排序
 9                 temp = a[j - 1];
10                 a[j - 1] = a[j];
11                 a[j] = temp;
12             }
13     }
14 }

優化的冒泡排序

由於可能在前幾次就已經排好序，但是在上一種冒泡排序中仍然需要一直遍歷到最後。

優化措施：設置一個標誌，如果這一趟發生了交換，則為true，否則為false。明顯如果有一趟沒有發生交換，說明排序已經完成。

 1 public void BubbleSort1(int[] a) {
 2     int temp = 0;
 3     int len = a.length;
 4     boolean flag = true;
 5     while (flag) {
 6         flag = false;
 7         for (int j = 1; j < len - 1; j++)
 8             if (a[j - 1] > a[j]) {
 9                 // 註意分清是a[j-1]還是a[j]不然容易出現邊界問題
10                 // 從小到大排序
11                 temp = a[j - 1];
12                 a[j - 1] = a[j];
13                 a[j] = temp;
14                 // 設置標誌位
15                 flag = true;
16             }
17     }
18 }

2、快速排序

快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分為兩個子串行（sub-lists）。

算法步驟：

1） 從數列中挑出一個元素，稱為 “基準”（pivot）

2 ）重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作。

3 ）遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會退出，因為在每次的叠代（iteration）中，它至少會把一個元素擺到它最後的位置去。

 1 private static void quick_sort(int[] arr, int low, int high) {
 2     // 解決和合並
 3     if (low <= high) {
 4         int mid = partition(arr, low, high);
 5         // 遞歸
 6         quick_sort(arr, low, mid - 1);
 7         quick_sort(arr, mid + 1, high);
 8     }
 9 
10 }
11 
12 private static int partition(int[] arr, int low, int high) {
13     // 分解
14     int pivot = arr[high];
15     int i = low - 1;
16     int temp;
17     for (int j = low; j < high; j++) {
18 
19         if (arr[j] < pivot) {
20             i++;
21             temp = arr[i];
22             arr[i] = arr[j];
23             arr[j] = temp;
24         }
25     }
26     // 交換中間元素和privot
27     temp = arr[i + 1];
28     arr[i + 1] = arr[high];
29     arr[high] = temp;
30     return i + 1;
31 
32 }

3、歸並排序

歸並排序（Merge sort）是建立在歸並操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。

算法步驟：

1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列

2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置

3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置

4. 重復步驟3直到某一指針達到序列尾

5. 將另一序列剩下的所有元素直接復制到合並序列尾

 1 public static int[] sort(int[] nums, int low, int high) {  
 2     int mid = (low + high) / 2;  
 3     if (low < high) {  
 4         // 左邊  
 5         sort(nums, low, mid);  
 6         // 右邊  
 7         sort(nums, mid + 1, high);  
 8         // 左右歸並  
 9         merge(nums, low, mid, high);  
10     }  
11     return nums;  
12 }  
13 
14 public static void merge(int[] nums, int low, int mid, int high) {  
15     int[] temp = new int[high - low + 1];  
16     int i = low;// 左指針  
17     int j = mid + 1;// 右指針  
18     int k = 0;  
19 
20     // 把較小的數先移到新數組中  
21     while (i <= mid && j <= high) {  
22         if (nums[i] < nums[j]) {  
23             temp[k++] = nums[i++];  
24         } else {  
25             temp[k++] = nums[j++];  
26         }  
27     }  
28 
29     // 把左邊剩余的數移入數組  
30     while (i <= mid) {  
31         temp[k++] = nums[i++];  
32     }  
33 
34     // 把右邊邊剩余的數移入數組  
35     while (j <= high) {  
36         temp[k++] = nums[j++];  
37     }  
38 
39     // 把新數組中的數覆蓋nums數組  
40     for (int k2 = 0; k2 < temp.length; k2++) {  
41         nums[k2 + low] = temp[k2];  
42     }  
43 }

4、選擇排序

選擇排序(Selection sort)也是一種簡單直觀的排序算法。

算法步驟：

1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2）再從剩余未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。

3）重復第二步，直到所有元素均排序完畢。

 1 public int[] ChoseSort(int[] intArr){  
 2     for(int i=0;i<intArr.length;i++){  
 3         int lowIndex = i;  
 4 
 5         for(int j=i+1;j<intArr.length;j++){  
 6             if(intArr[j]<intArr[lowIndex]){  
 7                 lowIndex = j;  
 8             }  
 9         }  
10 
11         //將當前第一個元素與它後面序列中的最小的一個 元素交換，也就是將最小的元素放在最前端  
12         int temp = intArr[i];             
13         intArr[i] = intArr[lowIndex];  
14         intArr[lowIndex] = temp;  
15     }  
16 
17     return intArr;  
18 }

5、堆排序

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。
堆排序的平均時間復雜度為Ο(nlogn) 。

算法步驟：

1）創建一個堆H[0..n-1]

2）把堆首（最大值）和堆尾互換

3）把堆的尺寸縮小1，並調用shift_down(0),目的是把新的數組頂端數據調整到相應位置

4） 重復步驟2，直到堆的尺寸為1

調整堆部分不太好寫建議參考 http://blog.csdn.net/jdream314/article/details/6634863
最後給出一張各算法的性能比較圖

參考：http://www.cricode.com/3212.html

http://blog.csdn.net/morewindows/article/details/7961256

排序算法（java版）