演算法系列（四）排序演算法中篇--歸併排序和快速排序

robert_chao發表於2016-05-30
演算法排序

在演算法系列（三）排序演算法上篇 一文中，介紹了氣泡排序，插入排序和選擇排序演算法。這篇文章繼續講解排序演算法。

概述

氣泡排序，插入排序和選擇排序演算法這些演算法的時間複雜度都是O(N^2),是否有更高效的排序演算法呢？當然有了，堆排序，歸併排序，快速排序，它們的時間複雜度都是O(nlogn)。堆排序使用了樹結構，到目我們前還沒有介紹樹相關的演算法，這裡先分析歸併排序跟快速排序。

歸併排序

基本原理

歸併排序使用了一個被稱為分治法的通用模式，在分治法中，我們將問題分解為類似於原子問題的問題，遞迴的求解這些子問題，然後再合併這些自問題的解來得出原問題的解。
分治法的一般步驟
1、分解：把一個問題分解為多個子問題，這些子問題是更小例項上的原問題。
2、解決：遞迴求解自問題。當子問題足夠小時，按照基礎情況求解。
3、合併：把自問題的解合併為原問題的解。
歸併操作的工作原理如下：
第一步：申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合併後的序列
第二步：設定兩個指標，最初位置分別為兩個已經排序序列的起始位置
第三步：比較兩個指標所指向的元素，選擇相對小的元素放入到合併空間，並移動指標到下一位置
重複步驟3直到某一指標超出序列尾
將另一序列剩下的所有元素直接複製到合併序列尾

具體過程

對於歸併排序的實現，我們看一下《演算法基礎》中給的一個歸併的例子

程式碼實現

（比較容易理解，但是寫的不是很好，合併方法可以優化）

package com.algorithm.sort;

/**
 * 歸併排序
 * 
 * @author chao
 *
 */
public class MergeSort {
	/**
	 * 歸併排序
	 * 
	 * @param num
	 * @param start
	 * @param end
	 */
	public static void sort(int num[], int start, int end) {
		if (start >= end) {
			return;
		}
		int mid = (start + end) / 2;
		sort(num, start, mid);
		sort(num, mid + 1, end);
		merge(num, start, mid, end);

	}

	/**
	 * num[start]到num[mid]是有序的，num[mid+1]到num[end]是有序的，
	 * 重新合併陣列，使陣列num[start]到num[end]有序
	 * 
	 * @param num
	 * @param start
	 * @param mid
	 * @param end
	 */
	public static void merge(int[] num, int start, int mid, int end) {
		int[] num1 = new int[mid - start + 1];
		int[] num2 = new int[end - mid];
		int i, j, k;
		for (i = start; i <= end; i++) {
			if (i - start < num1.length) {
				num1[i - start] = num[i];
			} else {
				num2[i - start - num1.length] = num[i];
			}
		}
		i = j = k = 0;
		while (i < num1.length && j < num2.length) {
			if (num1[i] <= num2[j]) {
				num[start + k++] = num1[i++];
			} else {
				num[start + k++] = num2[j++];
			}
		}

		while (i < num1.length) {
			num[start + k++] = num1[i++];
		}
		while (j < num2.length) {
			num[start + k++] = num2[j++];
		}
	}

	public static void main(String[] args) {
		int[] num = { 1, 5, 3, 2 };
		sort(num, 0, num.length - 1);
		for (int i = 0; i < num.length; i++)
			System.out.print(num[i] + " ");
	}
}

時間複雜度

最好最的時間複雜度都是O(nlogn)
儘管歸併排序效率很高，但是還是有一些缺點。歸併排序並不是原址的，它必須將整個陣列進行完全拷貝，如果空間非常寶貴，不適合使用歸併排序。

快速排序

基本原理

和歸併排序一樣，快速排序也使用分治模式
假設要排序的陣列是A[0]……A[N-1]，首先任意選取一個資料（通常選用第一個資料）作為關鍵資料，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一躺快速排序。一躺快速排序的演算法是：
1、設定兩個變數I、J，排序開始的時候I：=1，J：=N-1；
2、以第一個陣列元素作為關鍵資料，賦值給X，即X=A[1]；
3、從J開始向前搜尋，即由後開始向前搜尋（J=J-1），找到第一個小於X的值，兩者交換；
4、從I開始向後搜尋，即由前開始向後搜尋（I=I+1），找到第一個大於X的值，兩者交換；
5、重複第3、4步，直到I=J；

具體過程
待排序的陣列A的值分別是：（初始關鍵資料X=49）
                   A[0]     A[1]     A[2]     A[3]     A[4]      A[5]     A[6]：
                     49        38       65       97       76       13        27
進行第一次交換後：   27        38       65       97       76       13        49
                   ( 按照演算法的第三步從後面開始找)
進行第二次交換後：   27        38       49       97       76       13        65
                  ( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時I：=3 )
進行第三次交換後：   27        38       13       97       76       49        65
( 按照演算法的第五步將又一次執行演算法的第三步從後開始找)
進行第四次交換後：   27        38       13       49       76       97        65
( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時J=4 )
此時再執行第三不的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是：
27        38       13       49       76       97        65，
即所有大於49的數全部在49的後面，所有小於49的數全部在49的前面。

程式碼實現

package com.algorithm.sort;

/**
 * 快速排序
 * 
 * @author chao
 *
 */
public class QuickSort {
	/**
	 * 快速排序
	 * 
	 * @param num
	 * @param left
	 * @param right
	 */
	public static void sort(int[] num, int left, int right) {
		if (left < right) {
			int dp = partition(num, left, right);
			sort(num, left, dp - 1);
			sort(num, dp + 1, right);
		}
	}

	/**
	 * 資料分組
	 * 
	 * @param num
	 * @param left
	 * @param right
	 */
	public static int partition(int[] num, int left, int right) {
		int pivot = num[left];
		while (left < right) {
			while (left < right && num[right] >= pivot)
				right--;
			if (left < right)
				num[left++] = num[right];
			while (left < right && num[left] <= pivot)
				left++;
			if (left < right)
				num[right--] = num[left];
		}
		num[left] = pivot;
		return left;
	}

	public static void main(String[] args) {
		int[] num = { 1, 5, 3, 2 };
		sort(num, 0, num.length - 1);
		for (int i = 0; i < num.length; i++)
			System.out.print(num[i] + " ");

	}

}

複雜度分析

最好的情況是樞紐元選取得當，每次都能均勻的劃分序列。 時間複雜度O(nlogn)
最壞情況是樞紐元為最大或者最小數字，那麼所有數都劃分到一個序列去了 時間複雜度為O(n^2)


演算法實現程式碼github地址為我的github

後續會不斷補充，有些地方寫的可能有問題，請多指教。

歡迎掃描二維碼，關注公眾賬號




相關文章