双路归并排序法（自上向下）

算法原理

    归并排序（Merge Sort）是利用“归并” 技术来进行排序。归并是指将若干个已排序的 子 文件 合并 成 一个 有序 的 文件。

    两路 归并 算法 的 基本 思路： 设 两个 有序 的 子 文件（ 相当于 输入 堆） 放在 同一 向量 中 相邻 的 位置 上： A[ low… m]， a[ m+ 1… high]， 先 将它 们 合并 到 一个 局部 的 暂存 向量 Temp（ 相当于 输出 堆） 中， 待 合并 完成 后 将 Temp 复制 回 A[ low... high] 中。

    归并 排序 有两 种 实现 方法： 自 底 向上 和 自 顶 向下。

    自 底 向上 方法 的 基本 思想：

    （1） 第 1 趟 归并 排序 时， 将 待 排序 的 文件 A[ 1... n] 看作 n 个 长度 为 1 的 有序 子 文件， 将 这些 子 文件 两两 归并。 若 n 为 偶数， 则 得到 n/ 2 个 长度 为 2 的 有序 子 文件； 若 n 为 奇数， 则 最后 一个 子 文件 不 参与 归并。 故 本 趟 归并 完成 后， 前 n/ 2 个 有序 子 文件 长度 为 2， 但 最后 一个 子 文件 长度 仍 为 1。

    （2） 第 2 趟 归并 则 是将 第 1 趟 归并 所 得到 的 n/ 2 个 有序 的 子 文件 两两 归并， 如此 反复， 直到 最后 得到 一个 长度 为 n 的 有序 文件 为止。

    （3） 上述 每次 归并 操作， 均 是将 两个 有序 的 子 文件 合并 成 一个 有序 的 子 文件， 故称 其为“ 二路 归并 排序”。 类似 地， 有 k（ k> 2） 路 归并 排序。

    自 顶 向下 算法 的 设计， 形式 更为 简洁。 设 归并 排序 的 当前 区间 是 A[ low... high]， 步骤 如下。

    （1） 分解： 将 当前 区间 一分为二， 即 求 分裂 点。

    （2） 求解： 递归 地 对 两个 子 区间 A[ low... mid] 和 A[ mid+ 1... high] 进行 归并 排序。

    （3） 组合： 将 已 排序 的 两个 子 区间 A[ low... mid] 和 A[ mid+ 1... high] 归并 为 一个 有序 的 区间 R[ low… high]。

    （4） 递归 的 终结 条件： 子 区间 长度 为 1（ 一个 记录 自然 有序）。

算法草稿

 

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define SUCCESS		0
#define PARAM_ERR	-1
#define ALLOC_ERR	-2

/*
 * 合并两个子数组 [lstart, lend] [rstart, rend]
 */
int MergeImpl(int * array, int * temp,  int lstart, int lend, int rstart, int rend){
	if(NULL == array || NULL == temp){
		printf("%s para error\n", __func__);
		return PARAM_ERR;
	}

#if 1
	int size = 0; /* 两个待合并的素组总长度 */
	int i = 0, j = 0, k = 0;

	size = (lend - lstart +  1) + (rend - rstart + 1);
	i = lstart;
	j = rstart;
	k = 0;
	
#ifdef DEBUG
	int m = 0;
	printf("Befor %s: size = %d \n", __func__, size);	
	for(m = lstart; m <= rend ; m++){
		printf("array[%d] = %d ", m, array[m]); 	
	}
	printf("\n");
#endif

	/*清空待合并数组*/
	memset(temp, 0x0, size * sizeof(int));

	/* 升序 */
	while ( (i <= lend) && (j <= rend)){
		if(array[i] <= array[j]){
			temp[k++] = array[i++];
		} else {
			temp[k++] = array[j++];
		}
	}

	/* 左子组还有 */
	while (i <= lend){
		temp[k++] = array[i++];
	}
	
	/* 右子组还有 */
	while (j <= rend){
		temp[k++] = array[j++];
	}	

	/*
	 * 合并后的数组，复制回array 
	 * 因为左右两个子组是相邻的，所以从lstart顺序复制如array
	 */
	i = lstart;
	for(k = 0; k < size; k++){
		array[i++] = temp[k];		
	}

#ifdef DEBUG
	printf("After: %s \n", __func__);
	for(m = 0; m < size ; m++){
		printf("temp[%d] = %d ", m, temp[m]);		
	}
	printf("\n");

	for(m = lstart; m <= rend ; m++){
		printf("array[%d] = %d ", m, array[m]);		
	}

	printf("\n\n");
#endif


#else
	int size = 0; /* 两个待合并的素组总长度 */
	int lpos = 0, rpos = 0, tpos = 0, k = 0;

	size = rend - lstart + 1;
	lpos = lstart;
	rpos = rstart;
	tpos = lstart;

	/* 升序 */
	while ( (lpos <= lend) && (rpos <= rend)){
		if(array[lpos] <= array[rpos]){
			temp[tpos++] = array[lpos++];
		} else {
			temp[tpos++] = array[rpos++];
		}
	}


	/* 左子组还有 */
	while (lpos <= lend){
		temp[tpos++] = array[lpos++];
	}
	
	/* 右子组还有 */
	while (rpos <= rend){
		temp[tpos++] = array[rpos++];
	}	

	/*
	 * 合并后的数组，复制回array 
	 * 因为左右两个子组是相邻的，所以从lstart顺序复制如array
	 */
	for(k = 0; k < size; k++, rend--){
		array[rend] = temp[rend];	
	}

#endif
	return SUCCESS;
	
}

/*
 * 本函数真正的合并排序实现
 */
int MergeSortImpl(int * array, int * temp,  int low, int high){
	if(NULL == array || NULL == temp){
		printf("%s para error\n", __func__);
		return PARAM_ERR;
	}

	int i = 0, j = 0;
	int size = 0; /* 排序分组大小 */
	int mid = 0;
	
	size =  high - low + 1;
	/* 递归终止条件，数组中只有一个元素*/
	if(size <= 1){
		goto out;		
	}

	/*
	 * 两路合并排序，自定向下，取得中间点 
	 * 注意 low 和 high 的中间的不是 size /2 而是 (low + high) / 2 ！ 千万注意
	 */
	mid = (low + high) / 2; /*左子组：[low, mid], 右子组：[mid+1, high]*/
	
	/* 对左子组两路合并排序*/
	MergeSortImpl(array, temp, low, mid);

	/* 对右子组两路合并排序*/
	MergeSortImpl(array, temp, mid + 1 , high);

	/* 对已排序的两个子组进行合并 */
	MergeImpl(array, temp, low, mid, mid + 1, high);

out:
	return SUCCESS;
}


int MergeSort(int * array, int size){
	if(NULL == array){
		printf("%s para error\n", __func__);
		return PARAM_ERR;
	}

	int * temp = NULL;

	/*这里是合并排序的接口，完成准备工作*/
	temp = (int *) malloc (size * sizeof(int));
	if(NULL == temp){
		printf("%s alloc memory error\n",__func__);
		return ALLOC_ERR;
	}

	MergeSortImpl(array, temp, 0, size - 1);

	/* 删除已分配空间 */
	free(temp);
	temp = NULL;

	return SUCCESS;	
}


int main(int argc, char ** argv){
	int array[10] = {7,3,5,8,0,9,1,2,4,6};
	int i = 0;

	printf("Before sort: \n");
	for(i = 0; i < 10; i++){
		printf("  %d  ", array[i]);
	}
	printf("\n");

	MergeSort(array, 10);

	printf("after sort: \n");
	for(i = 0; i < 10; i++){
		printf("  %d  ", array[i]);
	}
	printf("\n");
	
	return 0;
}

调试编译

gcc MergeSort.c -DDEBUG

调试输出

Before sort:
  7    3    5    8    0    9    1    2    4    6
Befor MergeImpl: size = 2
array[0] = 7 array[1] = 3
After: MergeImpl
temp[0] = 3 temp[1] = 7
array[0] = 3 array[1] = 7

Befor MergeImpl: size = 3
array[0] = 3 array[1] = 7 array[2] = 5
After: MergeImpl
temp[0] = 3 temp[1] = 5 temp[2] = 7
array[0] = 3 array[1] = 5 array[2] = 7

Befor MergeImpl: size = 2
array[3] = 8 array[4] = 0
After: MergeImpl
temp[0] = 0 temp[1] = 8
array[3] = 0 array[4] = 8

Befor MergeImpl: size = 5
array[0] = 3 array[1] = 5 array[2] = 7 array[3] = 0 array[4] = 8
After: MergeImpl
temp[0] = 0 temp[1] = 3 temp[2] = 5 temp[3] = 7 temp[4] = 8
array[0] = 0 array[1] = 3 array[2] = 5 array[3] = 7 array[4] = 8

Befor MergeImpl: size = 2
array[5] = 9 array[6] = 1
After: MergeImpl
temp[0] = 1 temp[1] = 9
array[5] = 1 array[6] = 9

Befor MergeImpl: size = 3
array[5] = 1 array[6] = 9 array[7] = 2
After: MergeImpl
temp[0] = 1 temp[1] = 2 temp[2] = 9
array[5] = 1 array[6] = 2 array[7] = 9

Befor MergeImpl: size = 2
array[8] = 4 array[9] = 6
After: MergeImpl
temp[0] = 4 temp[1] = 6
array[8] = 4 array[9] = 6

Befor MergeImpl: size = 5
array[5] = 1 array[6] = 2 array[7] = 9 array[8] = 4 array[9] = 6
After: MergeImpl
temp[0] = 1 temp[1] = 2 temp[2] = 4 temp[3] = 6 temp[4] = 9
array[5] = 1 array[6] = 2 array[7] = 4 array[8] = 6 array[9] = 9

Befor MergeImpl: size = 10
array[0] = 0 array[1] = 3 array[2] = 5 array[3] = 7 array[4] = 8 array[5] = 1 array[6] = 2 array[7] = 4 array[8] = 6 array[9] = 9
After: MergeImpl
temp[0] = 0 temp[1] = 1 temp[2] = 2 temp[3] = 3 temp[4] = 4 temp[5] = 5 temp[6] = 6 temp[7] = 7 temp[8] = 8 temp[9] = 9
array[0] = 0 array[1] = 1 array[2] = 2 array[3] = 3 array[4] = 4 array[5] = 5 array[6] = 6 array[7] = 7 array[8] = 8 array[9] = 9

after sort:
  0    1    2    3    4    5    6    7    8    9