合并排序

合并排序

题目：

​ 合并排序。

分析:

​ 合并排序（二路）算法是用分治策略实现对n个元素进行排序的算法。基本思想是：将待排序元素分成大小大致相同的两个子集合，分别对两个子集合进行排序，最终将排好序的子集合合并成要求的排好序的集合。因此递归方程为：
$$T(n)=\{\begin{array}{llc}O(1)& & n\le 0\\ 2T(n/2)+O(n)& & n>0\end{array}$$
可得时间复杂度 $T(n)=nlo{g}_{2}n$ 。

实现一：递归

mergeSort主算法实现：

1. 边界条件为：left >= right
2. 二分，从中间取开分别递归

// 二分
int mid = (left+right)/2;
mergeSort(a, left, mid);
mergeSort(a, mid+1, right);

3. 合并

// 合并
merge(a, b, left, mid, right);

4. 将零时放在b上的元素拷贝至a

// 还原到a上
copy(a, b, left, right);

merge合并实现：

1. 分别记录左右两半的起始位置：

int i = left, j = mid+1;

2. 另起一个变量记录当前排序元素位置，从左半部分起始位置开始到右半部分结束位置为止：

for(int k=left; k<=right; k++){
	... ...		
}

3. 循环体中排序需要考虑以下四点：

• 左边已经全部排完序，将右边全部加入b中
• 右边已经全部排完序，将左边全部加入b中
• 左边小于等于右边，将左边赋值到b中
• 左边大于等于右边，将右边赋值到b中

for(int k=left; k<=right; k++){
    if(i > mid){
        // 左边已经全部排完序，将右边全部加入b中
        b[k] = a[j];
        j++;
    } else if(j > right){
        // 右边已经全部排完序，将左边全部加入b中
        b[k] = a[i];
        i++;
    } else if(a[i] <= a[j]){
        // 左边小于等于右边，将左边赋值到b中
        b[k] = a[i];
        i++;
    } else {
        // 左边大于等于右边，将右边赋值到b中
        b[k] = a[j];
        j++;
    }
}

算法书中是将前两步通过内层循环来实现的，如下：

while(k<=right){
    if(a[i] <= a[j]){
        // 左边小于等于右边，将左边赋值到b中
        b[k++] = a[i++];
    } else {
        // 左边大于等于右边，将右边赋值到b中
        b[k++] = a[j++];
    }
    if(i > mid){
        // 左边已经全部排完序，将右边全部加入b中
        while(j<=right){
            b[k++] = a[j++];
        }
    } else if(j > right){
        // 右边已经全部排完序，将左边全部加入b中
        while(i<=mid){
            b[k++] = a[i++];
        }
    }
}

copy还原实现：

// 还原
void copy(int a[], int b[], int left, int right){
	for(int i=left; i<=right; i++){
		a[i] = b[i];
	}
}

总体代码：

#include<stdio.h>
// 合并算法
void mergeSort(int a[], int left, int right){
	if(left<right){
		// 二分
		int mid = (left+right)/2;
		mergeSort(a, left, mid);
		mergeSort(a, mid+1, right);
		int b[right+1];
		// 合并
		merge(a, b, left, mid, right);
		// 还原到a上
		copy(a, b, left, right);
	}
}
// 合并
void merge(int a[], int b[], int left, int mid, int right){
	int i = left, j = mid+1;
	for(int k=left; k<=right; k++){
		if(i > mid){
			// 左边已经全部排完序，将右边全部加入b中
			b[k] = a[j];
			j++;
		} else if(j > right){
			// 右边已经全部排完序，将左边全部加入b中
			b[k] = a[i];
			i++;
		} else if(a[i] <= a[j]){
			// 左边小于等于右边，将左边赋值到b中
			b[k] = a[i];
			i++;
		} else {
			// 左边大于等于右边，将右边赋值到b中
			b[k] = a[j];
			j++;
		}
	}
}
// 还原
void copy(int a[], int b[], int left, int right){
	for(int i=left; i<=right; i++){
		a[i] = b[i];
	}
}
void main(){
	int a[10] = {4,7,3,1,2,6,6,9,8};
	int length = sizeof(a) / sizeof(int);
	mergeSort(a, 0, length-1);
	for(int i=0; i<length; i++){
		printf("%d ", a[i]);
	}
	return;
}

实现二：非递归