【C】分治算法

分治算法虽然听起来有可能有点陌生，但是实质上绝对是见过。比如在有序顺序表中的二分查找就是分治法的其中一个实例。它的时间复杂度经常性能把一个问题从O(n)降为O(nlogn)，虽然它的代码往往涉及到递归调用，看起来非常复杂。

比如以下的一个简单得不能再简单的问题，求数组int a[4]={1,3,2,4}的最大值。第一反应想都不用想就得出如下的代码：

#include<stdio.h>
void main(){
	int a[4]={1,3,2,4};
	int max=a[0];
	for(int i=0;i<4;i++){
		if(max<a[i]){
			max=a[i];
		}
	}
	printf("%d",max);
}

先设定最大值为a[0]，然后遍历这个数组的每一个元素，看它是否大于最大值，如果是，设这个元素为最大值，时间复杂度为O(n)，这里4个元素，就要比较4次。

然而，如果用分治法去比较：

不停地将数组拆分成n/2，直到无法再分割，就比如这里4个元素{1,3,2,4}，先将其拆分成{1,3},{2,4}，已经无法再拆分了，就先从各个小元组中最大值再组成数组{3,4}，从而再从这个新数组中，求最大值为4，这里仅比较3次，{1,3},{2,4}的时候2次，{3,4}1次，时间复杂度为O(nlogn)，从O(n)将成O(nlogn)是个了不起的成就，然而写成代码却是涉及到递归调用，无比地蛋疼：

#include<stdio.h>
int getMax(int array[], int begin, int end){
	int Max1 = 0;
	int Max2 = 0;
	if (begin == end) {//划分到最后，剩余1个数
		return array[begin] = array[end];
	}
	else if(begin+1==end){//划分到最后，剩余2个数
		return array[begin]> array[end]?array[begin]: array[end];//谁大返回谁。
	}
	else{//如果剩余的数多于2个，划分成两段，选出这两段的最大值
		int mid=(begin+end)/2;
		Max1=getMax(array,begin,mid);
		Max2=getMax(array,mid+1,end);
		return Max1>Max2?Max1:Max2;
	}
};
void main(){
	int a[4]={1,3,2,4};	
	printf("%d",getMax(a,0,3));
}

然而，其时间复杂度却减少了，这就是分治算法。

下面再用一道2014年上半年的软件设计师软考题来说明这个问题，题目是这样的：

采用归并排序对n个元素进行递增排序时，首先将n个元素的数组分成各含n/2个元素的两个子数组，然后用归并排序对两个子数组进行递归排序，最后合并两个已经排好序的子数组得到排序结果，用C语言现实上述递归排序，其中常量和变量规定如下：arr是待排序的数组，一个子数组的位置从p到q，另一个子数组的位置从q+1到r，begin与end是待排序数组的起止位置，left与right是临时存放待合并的两个子数组，n1与n2为两个子数组的长度，i,j,k为循环变量，mid为临时变量。

#include<stdio.h>
#include<stdlib.h>
#define MAX 65536
void merge(int arr[],int p, int q,int r){
	int *left,*right;
	int n1,n2,i,j,k;
	//计算左右数组应有的长度
	n1=q-p+1;
	n2=r-q;
	//开拓左由数组的空间
	if((left=(int*)malloc((n1+1)*sizeof(int)))==NULL){
		perror("malloc error");
		exit(1);
	}
	if((right=(int*)malloc((n2+1)*sizeof(int)))==NULL){
		perror("malloc error");
		exit(1);
	}
	//讲待排序数组的平分成两个n/2长的数组，分别存进左右数组
	for(i=0;i<n1;i++){
		left[i]=arr[p+i];
	}
	left[i]=MAX;//封口
	for(i=0;i<n2;i++){
		right[i]=arr[(q+1)+i];//q+1是右数组的起始位置，而不是q，注意！
	}
	right[i]=MAX;//封口
	i=0,j=0;
	for(k=p;k<=r;k++){//选择左右数组的小者，放入排序后的数组，也就是覆盖原来的数组中存在的内容
		if(left[i]>right[j]){
			arr[k]=right[j];
			j++;
		}else{
			arr[k]=left[i];
			i++;
		}
	}
}
void mergeSort(int arr[],int begin,int end){
	int mid;
	if(begin<end){//如果begin=end或者begin>end，证明分无可分，就不分了
		mid=(begin+end)/2;//将数组分成2半
		mergeSort(arr,begin,mid);//要求对左部分进行排序
		mergeSort(arr,mid+1,end);//要求对右部分进行排序
		merge(arr,begin,mid,end);//真正的排序算法
	}
}
void main(){
	int a[4]={4,2,1,3};
	mergeSort(a,0,3);
	for(int i=0;i<4;i++){
		printf("%d",a[i]);
	}
}

这里的各趟递归，排序之后的结果如下所示：

归并排序的最好、最坏和平均时间复杂度都是O(nlogn)，而空间复杂度是O(n)，比较次数介于(nlogn)/2和(nlogn)-n+1，赋值操作的次数是(2nlogn)。因此可以看出，归并排序算法比较占用内存，但却是效率高且稳定的排序算法。这里涉及到对递归式f(n)=2*f(n/2)+O(n)的分析，比较难，记住它就行。

比起最简单的冒泡排序O(n2)，时间复杂度降低得非常明显。