排序演算法

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

1、冒泡演算法

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

演算法步驟：

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

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

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

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

<span style="font-family:Microsoft YaHei;font-size:14px;">public void BubbleSort(int[] a) {
		int temp = 0;
		int len = a.length;
		for (int i = 0; i < len; i++) {
			for (int j = 1; j < len - i; j++)
				if (a[j - 1] > a[j]) {
					//注意分清是a[j-1]還是a[j]不然容易出現邊界問題
					// 從小到大排序
					temp = a[j - 1];
					a[j - 1] = a[j];
					a[j] = temp;
				}
		}
	}</span>
 

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

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

<span style="font-family:Microsoft YaHei;font-size:14px;">public void BubbleSort1(int[] a) {
		int temp = 0;
		int len = a.length;
		boolean flag = true;
		while (flag) {
			flag = false;
			for (int j = 1; j < len - 1; j++)
				if (a[j - 1] > a[j]) {
					// 注意分清是a[j-1]還是a[j]不然容易出現邊界問題
					// 從小到大排序
					temp = a[j - 1];
					a[j - 1] = a[j];
					a[j] = temp;
					// 設定標誌位
					flag = true;
				}
		}
	}</span>
 

2、快速排序

快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序 n 個專案要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 演算法更快，因為它的內部迴圈（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分為兩個子序列（sub-lists）。

演算法步驟：
1） 從數列中挑出一個元素，稱為 “基準”（pivot），
2 ）重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割槽退出之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作。
3 ）遞迴地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞迴的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞迴下去，但是這個演算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

<span style="font-family:Microsoft YaHei;font-size:14px;">	private static void quick_sort(int[] arr, int low, int high) {
		// 解決和合並
		if (low <= high) {
			int mid = partition(arr, low, high);
			// 遞迴
			quick_sort(arr, low, mid - 1);
			quick_sort(arr, mid + 1, high);
		}

	}

	private static int partition(int[] arr, int low, int high) {
		// 分解
		int pivot = arr[high];
		int i = low - 1;
		int temp;
		for (int j = low; j < high; j++) {

			if (arr[j] < pivot) {
				i++;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		// 交換中間元素和privot
		temp = arr[i + 1];
		arr[i + 1] = arr[high];
		arr[high] = temp;
		return i + 1;

	}</span>

3、歸併排序

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

演算法步驟：

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

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

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

4. 重複步驟3直到某一指標達到序列尾

5. 將另一序列剩下的所有元素直接複製到合併序列尾

<span style="font-family:Microsoft YaHei;font-size:14px;">  public static int[] sort(int[] nums, int low, int high) {  
        int mid = (low + high) / 2;  
        if (low < high) {  
            // 左邊  
            sort(nums, low, mid);  
            // 右邊  
            sort(nums, mid + 1, high);  
            // 左右歸併  
            merge(nums, low, mid, high);  
        }  
        return nums;  
    }  
  
    public static void merge(int[] nums, int low, int mid, int high) {  
        int[] temp = new int[high - low + 1];  
        int i = low;// 左指標  
        int j = mid + 1;// 右指標  
        int k = 0;  
  
        // 把較小的數先移到新陣列中  
        while (i <= mid && j <= high) {  
            if (nums[i] < nums[j]) {  
                temp[k++] = nums[i++];  
            } else {  
                temp[k++] = nums[j++];  
            }  
        }  
  
        // 把左邊剩餘的數移入陣列  
        while (i <= mid) {  
            temp[k++] = nums[i++];  
        }  
  
        // 把右邊邊剩餘的數移入陣列  
        while (j <= high) {  
            temp[k++] = nums[j++];  
        }  
  
        // 把新陣列中的數覆蓋nums陣列  
        for (int k2 = 0; k2 < temp.length; k2++) {  
            nums[k2 + low] = temp[k2];  
        }  
    }  </span>

4、選擇排序

選擇排序(Selection sort)也是一種簡單直觀的排序演算法。
演算法步驟：
1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2）再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。
3）重複第二步，直到所有元素均排序完畢。

<span style="font-family:Microsoft YaHei;font-size:14px;">  public int[] ChoseSort(int[] intArr){  
        for(int i=0;i<intArr.length;i++){  
            int lowIndex = i;  
              
            for(int j=i+1;j<intArr.length;j++){  
                if(intArr[j]<intArr[lowIndex]){  
                    lowIndex = j;  
                }  
            }  
              
            //將當前第一個元素與它後面序列中的最小的一個 元素交換，也就是將最小的元素放在最前端  
            int temp = intArr[i];             
            intArr[i] = intArr[lowIndex];  
            intArr[lowIndex] = temp;  
        }  
          
        return intArr;  
    } </span>

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

最後給出一張各演算法的效能比較圖