前言  

    之所以把歸併排序和快速排序放在一起探討，很明顯兩者有一些相似之處：這兩種排序演算法都採用了分治的思想。下面來逐個分析其實現思想。

歸併排序

實現思想   

    歸併的含義很明顯就是將兩個或者兩個以上的有序表組合成一個新的有序表。歸併排序中一般所用到的是2-路歸併排序，即將含有n個元素的序列看成是n個有序的子序列，每個子序列的長度為1，而後兩兩合併，得到n/2個長度為2或1的有序子序列，再進行兩兩合併。。。直到最後由兩個有序的子序列合併成為一個長度為n的有序序列。2-路歸併的核心操作是將一維陣列中前後相鄰的兩個有序序列歸併為一個有序序列。

    下面一系列圖展示了2-路歸併排序的過程:

    原始無序序列：

    第一次需要對各相鄰元素進行兩兩歸併，歸併後結果如下：

    第三次需要對上圖中相鄰色塊的元素進行兩兩歸併，歸併後的結果如下：

    接下來便是最後一次兩兩歸併了，歸併後便的到了有序的序列，如下：

    第一次實現的程式碼

    根據2-路歸併操作的思想，站在節省輔助空間的角度上考慮，我寫出的歸併操作的程式碼如下：

/*
將有序的arr[start...mid]和有序的arr[mid+1...end]歸併為有序的arr[start...end]
*/
void Merge(int *arr,int start,int mid,int end)
{
	int i = start;
	int j = mid+1;
	int k = 0;
	//brr為輔助陣列，
	int *brr = (int *)malloc((end-start+1)*sizeof(int));

	//比較兩個有序序列中的元素，將較小的元素插入到brr中
	while(i<=mid && j<=end)
	{	
		if(arr[i]<=arr[j])
			brr[k++] = arr[i++];
		else
			brr[k++] = arr[j++];
	}

	//將arr序列中剩餘的元素複製到brr中
	//這兩個語句只可能執行其中一個
	while(i<=mid)
		brr[k++] = arr[i++];
	while(j<=end)
		brr[k++] = arr[j++];

	//將brr中的元素複製到arr中，使arr[start...end]有序
	for(i=0;i<k;i++)
		arr[i+start] = brr[i];

	//釋放brr所佔的記憶體，並將其置為空
	free(brr);    
	brr = 0;
}
 

    呼叫上面的函式，得到的歸併排序的程式碼應該是這樣的：

/*
對arr[start...end]內的元素進行歸併排序
歸併排序後的順序為從小到大
*/
void MSort(int *arr,int start,int end)
{
	if(start < end)
	{
		int mid = (start+end)/2;
		MSort(arr,start,mid);		//左邊遞迴排序
		MSort(arr,mid+1,end);		//右邊遞迴排序
		Merge(arr,start,mid,end);	//左右序列歸併
	}
}
/*
將該排序演算法封裝起來
*/
void Merge_Sort(int *arr,int len)
{
	MSort(arr,0,len-1);
}
 

    輸入任意陣列來測試，結果也是正確的。

    第二次實現的程式碼

    我看很多書上或者網上的例子給出的程式碼都要在Merge函式中多傳入一個用來儲存歸併後有序序列的陣列，並在MSort函式中另外宣告一個臨時陣列，傳給該引數，這樣每次遞迴呼叫的時候都要在區域性宣告一個臨時陣列，很不好。正當我對自己的程式碼感覺良好時，看到了下面這段話：

    Merge例程是精妙的。如果對Merge的每個呼叫均區域性宣告一個臨時陣列（本人備註：即在MSort函式中宣告），那麼在任意時刻就可能有logN個臨時陣列處於活動期，這對於小記憶體的機器是致命的。另一方面，如果Merge例程動態分配並釋放最小量臨時記憶體，那麼由malloc佔用的時間會很多。嚴密測試指出，由於Merge位於MSort的最後一行，因此在任一時刻只需要一個臨時陣列活動，而且可以使用該臨時陣列的任意部分。（摘自Weiss資料結構與演算法分析）

    很明顯，我沒有考慮malloc所帶來的效率損耗，而且這裡說得很好，由於Merge位於MSort的最後一行，因此每一次遞迴呼叫中只會存在一個臨時陣列，而不會有上一層遞迴中宣告的臨時陣列（已經釋放掉了）。

    為了避免遞迴使用malloc和free，我們還是用這種經典的實現方式的好，程式碼（一塊貼上完整的測試程式碼）如下：

/*******************************
		    歸併排序
Author:蘭亭風雨 Date:2014-02-28
Email:[email protected]
********************************/
#include<stdio.h>
#include<stdlib.h>

/*
將有序的arr[start...mid]和有序的arr[mid+1...end]歸併為有序的brr[0...end-start+1],
而後再將brr[0...end-start+1]複製到arr[start...end]，使arr[start...end]有序
*/
void Merge(int *arr,int *brr,int start,int mid,int end)
{
	int i = start;
	int j = mid+1;
	int k = 0;

	//比較兩個有序序列中的元素，將較小的元素插入到brr中
	while(i<=mid && j<=end)
	{	
		if(arr[i]<=arr[j])
			brr[k++] = arr[i++];
		else
			brr[k++] = arr[j++];
	}

	//將arr序列中剩餘的元素複製到brr中
	//這兩個語句只可能執行其中一個
	while(i<=mid)
		brr[k++] = arr[i++];
	while(j<=end)
		brr[k++] = arr[j++];

	//將brr中的元素複製到arr中，使arr[start...end]有序
	for(i=0;i<k;i++)
		arr[i+start] = brr[i];
}

/*
藉助brr陣列對arr[start...end]內的元素進行歸併排序
歸併排序後的順序為從小到大
*/
void MSort(int *arr,int *brr,int start,int end)
{
	if(start < end)
	{
		int mid = (start+end)/2;
		MSort(arr,brr,start,mid);		//左邊遞迴排序
		MSort(arr,brr,mid+1,end);		//右邊遞迴排序
		Merge(arr,brr,start,mid,end);	//左右序列歸併
	}
}
/*
將該排序演算法封裝起來
*/
void Merge_Sort(int *arr,int len)
{
	int *brr = (int *)malloc(len*sizeof(int));
	MSort(arr,brr,0,len-1);
	free(brr);
	brr = 0;
}

int main()
{
	int num;
	printf("請輸入排序的元素的個數：");
	scanf("%d",&num);

	int i;
	int *arr = (int *)malloc(num*sizeof(int));
	printf("請依次輸入這%d個元素（必須為整數）：",num);
	for(i=0;i<num;i++)
		scanf("%d",arr+i);

	printf("歸併排序後的順序：");
	Merge_Sort(arr,num);
	for(i=0;i<num;i++)
		printf("%d ",arr[i]);
	printf("\n");

	free(arr);
	arr = 0;
	return 0;
}

    小總結

歸併排序的最好最壞和平均時間複雜度都是O（n*logn），但是需要額外的長度為n的輔助陣列（每次遞迴呼叫前都會釋放上次遞迴中傳入到Merge函式的brr陣列），因此空間複雜度為O（n）,而不會因為棧的最大深度為O（logn）而積累至O（n*logn）。佔用額外空間是歸併排序不足的地方，但是它是幾個高效排序演算法（快速排序、堆排序、希爾排序）中唯一穩定的排序方法。

快速排序

     如名所示，快速排序是已知的平均時間複雜度均為O（n*logn）的幾種排序演算法中效率最高的一個，該演算法之所以特別快，主要是由於非常精煉和高度優化的內部迴圈，它在最壞情況下的時間複雜度為O（n*n），但只要稍加努力（正確選擇樞軸元素）就可以避免這種情形。

    本部分的重點在於對分治思想的理解和程式碼的書寫，不打算過多地討論樞軸元素的選擇，因為這本身就不是一個簡單的問題，筆者對此也沒有什麼研究，更不敢造次。先來看實現思想。

    實現思想

    快速排序的基本思想如下：

    1、從待排序列中任選一個元素作為樞軸；

    2、將序列中比樞軸大的元素全部放在樞軸的右邊，比樞軸小的元素全部放在其左邊；

    3、以樞軸為分界線，對其兩邊的兩個子序列重複執行步驟1和2中的操作，直到最後每個子序列中只有一個元素。

    一趟快速排序（以排序後從小到大為例）的具體做法如下：

    附設兩個元素指標low和high，初值分別為該序列的第一個元素的序號和最後一個元素的序號，設樞軸元素的值為val，則首先從high所指位置起向前搜尋到第一個值小於val的元素，並將其和val互換位置，而後從low所指位置起向後搜尋到第一個值大於val的元素，並將其和val交換位置，如此反覆 ，直到low=high為止。

    我們上面說交換位置，只是為了便於理解，我們在前面幾篇內部排序的博文中一直在強調，應儘量避免比較多的元素交換操作，因此下面的分析和程式碼的實現中，我們並不是採取交換操作，而是先將樞軸元素儲存在val變數中，然後每次遇到需要交換的元素時，先將該元素賦給val所在的位置，而後再將該元素所在位置“挖空”，之後的每一次比較，就用需要交換的元素來填充上次“挖空”的位置，同時將交換過來的元素所在的位置再“挖空”，以等待下次填充。

    同樣為了便於理解，我們以下面的序列為例來展示快速排序的思想。

    下圖為無序序列的初始狀態，我們選取val為第一個元素4，low和high分別指向4和5：

相關推薦