关闭

分治法小结

标签: 算法编程分治算法递归算法
519人阅读 评论(0) 收藏 举报
分类:

这几天看完了分治算法,今天来做一个总结。

算法背景:分治法是算法学习中遇到的第一个算法设计思路(递归其实更偏向于一种编程技巧而并非单独的算法),但算法并不像刚接触算法的人该学习的内容。说白了,算法还是比较难的。

分治法是一种说起来简单做起来难的算法。说起来简单是因为算法的设计思路是完全符合人的思维过程的:分而治之嘛,在面向过程的程序设计中我们都有这样的体会,把一个复杂的问题模块化,每个模块实现一个小的功能,最后将各个模块连接起来完成最后的功能要求。这其实就是分治法的思想,把大问题分开成小问题,然后解决每个小问题,最后把解合并起来得到原问题的解。做起来难是因为在算法设计过程中“分”和“合”不像通常我们想的那么简单,并不是所有问题用一句n/2就可以将问题分开。就算是分开了,最后不能合并也是徒劳。

设计思路:从前面的叙述中我们其实已经可以知道其设计思路了,就是分开治理然后合并。在这个过程中合并是关键,而能否成功合并又和怎么分是息息相关的,所以你说分是关键也没问题。总之是分得好才能合,分的时候是要以能否合并为主要参考条件的。另外,分出来的子问题一般都是与原问题性质相同的小规模问题,这就使得递归算法派上了用场。递归和分治是联系很紧密的一对好兄弟,在程序设计过程中它们经常一起出现。

设计方法:分治法的设计方法可以用下面这段伪代码来说明

divide_and_conquer(P(n))
{
	if(n<=n0)//分治阀值
		return adhoc(P(n));
	else
	{
		divide P into smaller subinstances P1,P2,…,Pk//分解问题
			
		for(i=1; i<k; i++)//分别求解
			yi = divide_and_conquer(Pi);

		return merge(y1,y2,…,yk);//最后合并问题的解
	}
}
算法实例:分治法的例子有很多,但具有代表性的却很难找。原因前面也说了,针对每个问题,分和合的过程都是不同的,不同问题的分解合并过程可以没有任何关系。而且这个过程涉及的数学知识比较多,如果对相关数学知识不熟悉,那读懂别人的代码都是很困难的,别说自己去设计了。但例子还是要学习的,越是要根据具体情况来的算法例子越重要,否则就完全“形而上学”了。

例子1:快速排序

快速排序是大家比较熟悉的一种排序算法,所以今天就拿它先开刀吧。

快速排序的具体思想我就不多说了,简单说来就是划分,对子数组部分排序,再对子数组排序过程中还是先划分……从这个叙述中就可以看出,这个问题本身就是分治法和递归的练兵场,问题本身完全符合分治法的设计思路。

那就开始设计算法吧:首先是分,怎么把一个数组分开呢?了解算法的人肯定知道,是找一个枢轴值,让枢轴值左边儿的都小于它,右边儿的都大于它。这个过程我们可以用一个划分函数来实现;接下来就是治,治的过程也比较简单,因为子问题本身是和原问题性质相同的,所以可以利用递归技术来解决。这里主要注意两点,一是递归的出口,即基础步的规模阀值。以前设计递归算法时都是让n==1或n==0,即让规模达到最小,但在分治法中我们并不一定这么做,因为分治法的优势主要是用分和合的过程使问题规模减小了,但我们要知道,分和合的过程本身也是要有时间的。如果规模减小带来的时间优势比不过分和合带来的时间损耗,那分治法就失败了。但这个平衡点不是很好找,且为简单起见,我们在这里还是用n==1来作为递归出口。二是在递归时要用到上一步分的临界点,所以在划分算法中要得到划分的点;最后是合,这个就简单了,分治完以后数组就是排序好的,并不需要额外的处理。

有了上面的分析,我们可以写代码了

template<typename Type>
int split(Type A[],int low,int high)
{
	//功能:对数组元素部分划分,使前面的元素都小于枢轴点,后面的都大于枢轴点
	//输入:数组首地址A,划分起始位置下标low,划分终点位置下标high
	//输出:返回枢轴点新下标,划分好的新数组
	//说明:以A[low]元素作为划分枢点
	int i=low;
	Type x = A[low];
	for(int k = low+1;k <= high;k++)
	{
		if(A[k]<=x)
		{
			i = i+1;
			if(i!=k) swap(A[i],A[k]);
		}
	}
	swap(A[low],A[i]);
	return i;
}

template <typename Type>
void quick_sort(Type A[],int low,int high)
{
<span style="white-space:pre">	</span>//功能:快速排序
<span style="white-space:pre">	</span>//输入:待排序数组首地址A,排序下标范围low-high(含两个端点)
<span style="white-space:pre">	</span>//输出:排序好的数组
<span style="white-space:pre">	</span>//说明:递归调用自身直至low>=high成立,即只剩一个元素为止
	int k;
	if(low < high)
	{
		k = split(A,low,high);
		quick_sort(A,low,k-1);
		quick_sort(A,k+1,high);
	}
}
这个算法是时间复杂度我们都很熟悉,最坏情况下为O(n^2),最好情况下为O(nlogn),平均情况下约为1.44nlogn,这个不是我们讨论重点,就不多说了。另外算法应用了模板函数,以便适应不同类型的数据排序。

这个代码对于熟悉快排的人很简单,关键注意里面分治法的应用。

例子2:求无序数组中第k大的元素

这个例子也是一个比较经典的问题,对应其分治算法又称为选择算法。如果采用蛮力法,那算法的时间复杂度为O(kn)即算法的时间复杂度和k有直接关系,当k值较大(如n/2)时,那算法的时间复杂度趋向于O(n^2)。而采用选择算法可以使其算法的复杂度降为O(n)。

那就来说一说该怎么设计算法吧。

先是分,这个就比较烦人,怎么分呢?你想想,给你一个数组,没有顺序,从中间分?分开后分别找每个数组第k个大的元素?……这显然行不通。那怎么办呢?这个问题说实在的,一般人是真想不到。那就看看高手是怎么干的吧。先找出这个数组的近似中值元素,然后用这个中值元素将数组分为三部分:小于中值的、等于中值的、大于中值的。然后看这三部分元素个数跟k的关系,通过这个关系可以排除一部分数据,对剩下的数据进行继续处理即可。(这其实是一个剪枝类型的算法)

至于怎么找近似中值元素,我们采用这样的办法:把数据每几个分成一个小组,然后用一个常数时间求出每个小组的中值,然后再将这些中值分组,最后得到一个近似中值元素。有了这个元素可以通过一次历遍将整个数组分成三部分了,我们记为P,Q,R。

下面是治,这个也简单,看P、Q、R的大小跟k的关系,如果k<P,那第k大的元素就在P里面;如果P<k<=P+Q,那Q里面的元素就是第k大的元素;如果k>P+Q,那第k大元素就在Q里。接下来就是递归调用了。

最后的合同样可以省略了(两个例子都没有合的过程,失误啊,大家还是要多看别的例子)。

下面我们来看代码。

template <typename Type>
Type select(Type A[],size_t n,size_t k)
{
	int i,j,s,t;
	Type m,*p,*q,*r;
	if(n<=38)
	{
		merge_sort(A,n);
		return A[k-1];
	}
	p = new Type[3*n/4];
	q = new Type[3*n/4];
	r = new Type[3*n/4];
	for(i = 0;i<n/5;i++)
		mid(A,i,p);
	m = select(p,i,i/2+i%2);
	i = j = s = 0;
	for(t = 0; t<n; t++)
		if(A[t]<m)
			p[i++] = A[t];
		else if(A[t]==m)
			q[j++] = A[t];
		else
			r[s++] = A[t];
	if(i>k)
		return select(p,i,k);
	else if(i+j>=k)
		return m;
	else
		return select(r,s,k-i-j);
}
这个代码里面还涉及一个merge_sort(归并排序)算法和mid(求近似中值)算法。为了方便大家,在下面给出:

template <typename Type>
void merge(Type A[],size_t low,size_t mid,size_t high)
{
	//归并算法,low、mid、high都是下标
	Type *B = new Type[high-low+1];
	int i = low;
	int j = mid;
	int k = 0;
	while(i<mid && j<=high)
	{
		if(A[i]<A[j])
		{
			B[k++]=A[i++];
		}
		else
		{
			B[k++]=A[j++];
		}
	}
	while(i<mid) B[k++]=A[i++];
	while(j<=high) B[k++]=A[j++];
	for(int i=0; i<high-low+1; i++)
		A[i]=B[i];
	delete[] B;
}
//merge_sort的模板函数
template <typename Type>
void merge_sort(Type A[],size_t n)
{
	//归并算法
	n = n -1;//将n转化为下标
	if(n<=0) return;
	else
	{
		merge_sort(A,n/2+1);
		merge_sort(A+n/2+1,n-n/2);
		merge(A,0,n/2+1,n);
	}
}
//取A中每5个元素的中值
template <typename Type>
void mid(Type A[],size_t i,Type p[])
{
	size_t k = 5*i;
	if(A[k]>A[k+2])
		swap(A[k],A[k+2]);
	if(A[k+1]>A[k+3])
		swap(A[k+1],A[k+3]);
	if(A[k]>A[k+1])
		swap(A[k],A[k+1]);
	if(A[k+2]>A[k+3])
		swap(A[k+2],A[k+3]);
	if(A[k+1]>A[k+2])
		swap(A[k+1],A[k+2]);
	if(A[k+4]>A[k+2])
		p[i]=A[k+2];
	else if(A[k+4]>A[k+1])
		p[i]=A[k+4];
	else
		p[i]=A[k+1];
	
}
这里面涉及的程序处理也比较多,有精力大家可以看一看。最重要的还是理解分治法的应用过程。在select算法中,注意分治的阀值,正如前面所说,阀值不一定为n==1,这里取n==38,即当n小于38时不再分组,而是直接用归并排序得到其第k个大的元素。这也说明这个算法的应用条件是n非常大的情况,只有在这种情况下,其优点才能发挥出来。

最后总结:分治思想是程序设计中非常常见的一种思想,但真正的分治算法还是有一定难度的。关键在于分和合的处理过程,这个说多了也没啥用,还是慢慢体会吧。共勉







1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:31723次
    • 积分:919
    • 等级:
    • 排名:千里之外
    • 原创:56篇
    • 转载:0篇
    • 译文:0篇
    • 评论:9条
    最新评论