标签：
按照递归的思想可使我们得以从宏观上理解和把握应用问题的实质
深入挖掘和洞悉算法过程的主要矛盾和一般性模式
并最终设计和编写出简洁优美且精确紧凑的算法
然而，递归模式并非十全十美，其众多优点的背后也隐含着某些代价
首先，从递归跟踪分析的角度不难看出，递归算法所消耗的空间量主要取决于递归深度
故较之同一算法的迭代版，递归版往往需耗费更多空间，并进而影响实际的运行速度
另外，就操作系统而言，为实现递归调用需要花费大量额外的时间以创建、维护和销毁各递归实例，这些也会令计算的负担雪上加霜
有鉴于此，在对运行速度要求极高、存储空间需精打细算的场合，往往应将递归算法改写成等价的非递归版本
在线性递归算法中，若递归调用在递归实例中恰好以最后一步操作的形式出现，则称作尾递归（tail recursion）
比如代码Reverse(num, low, high)算法的最后一步操作，是对去除了首、末元素之后总长缩减两个单元的子数组进行递归倒置，即属于典型的尾递归
实际上，属于尾递归形式的算法，均可以简捷地转换为等效的迭代版本
void Reverse(int* num, int low, int high)
{
while (low < high) {
swap(num[low++], num[high--]);
}
}
请注意，尾递归的判断应依据对算法实际执行过程的分析，而不仅仅是算法外在的语法形式
比如，递归语句出现在代码体的最后一行，并不见得就是递归
严格的说，只有当该算法（除平凡递归基外）任一实例都终止于这一递归调用时，才属于尾递归
以线性递归版Sum()算法为例，尽管从表面看似乎最后一行是递归调用，但实际上却并非尾递归----实质的最后一次操作是加法运算
有趣的是，此类算法的非递归化转换方法仍与尾递归如出一辙
面对输入规模庞大的应用问题，每每感慨于头绪纷杂而无从下手的你，不妨从先哲孙子的名言中获得灵感----“凡治众如治寡，分数是也”
是的，解决此类问题的有效方法之一，就是将其分解为若干规模更小的子问题，再通过递归机制分别求解
这种分解持续进行，直到子问题规模缩减至平凡情况
这也就是所谓的分而治之（divide - and - conquer）策略
与减而治之策略一样，这里也要求对原问题重新表述，以保证子问题与原问题在接口形式上的一致
既然每一递归实例都可以做多次递归，故称作“多路递归”（multi - way - recursion）
通常都是将原问题一分为二，故称作”二分递归“（binary recursion）
需强调的是，无论是分解为两个还是更大常数个子问题，对算法总体的渐进复杂度并无实质影响
以下就采用分而治之的策略，按照二分递归的模式再次解决数组求和问题
新算法的思路是：
以居中的元素为界将数组一分为二，递归地对子数组分别求和，最后，子数组之和相加即为原数组的总和
int Sum(int num[], int low, int high) //数组求和算法（二分递归版）
{
if (low == high) {
return num[low]; //如遇递归基（区间长度已降至1），则直接返回该元素
} else { //否则(一般情况下low < high)，则
int mid = (low + high) >> 1; //以居中单元为界，将原区间一分为二
return Sum(num, low, mid) + Sum(num, mid+1, high); //递归对各子数组求和，然后合计
}
} //O(high - low - 1)，线性正比于区间的长度
为分析其复杂度，不妨只考查n = 2^m形式的长度
算法启动后经连续m = log2n次递归调用，数组区间的长度从最初的n首次缩减至1，并达到第一个递归基
实际上，刚到达任一递归基时，已执行的递归调用总是比递归返回多m =log2n次
更一般地，到达区间长度为2^k的任一递归实例之前，已执行的递归调用总是比递归返回多m-k次
因此，递归深度（即任一时刻的活跃递归实例的总数）不会超过m+1
鉴于每个递归实例仅需常数空间，故除数组本身所占的空间，该算法只需要O(m + 1) = O(logn)的附加空间
线性递归版Sum()算法共需O(n)的附加空间，就这一点而言，新的二分递归版Sum()算法有很大改进
与线性递归版Sum()算法一样，此处每一递归实例中的非递归计算都只需要常数时间
递归实例共2n - 1个，故新算法的运行时间为O(2n - 1) = O(n)，与线性递归版相同
此处每个递归实例可向下深入递归两次，故属于多路递归中的二分递归
二分递归与此前介绍的线性递归有很大区别
比如，在线性递归中整个计算过程仅出现一次递归基，而在二分递归过程中递归基的出现相当频繁，总体而言有超过半数的递归实例都是递归基
当然，并非所有问题都适宜于采用分治策略
实际上除了递归，此类算法的计算消耗主要来自两个方面
首先是子问题划分，即把原问题分解为形式相同、规模更小的多个子问题
其次是子解答合并，即由递归所得子问题的解，得到原问题的整体解
为使分治策略真正有效，不仅必须保证以上两方面的计算都能高效地实现，还必须保证子问题之间相互独立
----各子问题可独立求解，而无需借助其它子问题的原始数据或中间结果
否则，或者子问题之间必须传递数据，或者子问题之间需要相互调用，无论如何都会导致时间和空间复杂度的无谓增加
int Fibonacci(int n) //计算Fibonacci数列的第n项（二分递归版）：O(2^n)
{
if (n < 2) {
return n; //若达到递归基，直接取值
} else {
return (Fibonacci(n-1) + Fibonacci(n-2)); //否则，递归计算前两项，其和即为正解
}
}然而不幸的是，在这种场合采用二分递归的策略的效率极其低下
实际上，该算法需要运行O(2^n)时间才能计算出第n个Fibonacci数
这一指数复杂度的算法，在实际环境中毫无价值
算法的时间复杂度高达指数量级，究其原因在于，计算过程中所出现的递归实现的重复度极高
为消除递归算法中重复的递归实例，一种自然而然的思路和技巧，可以概括为：
借助一定量的辅助空间，在各子问题求解之后，及时记录下其对应的解答
比如，可以从原问题出发自顶而下，每遇到一个子问题，都首先查验它是否已经计算过，以期通过直接调阅记录解答，从而避免重新计算
也可以从递归基出发，自底而上递推地得出各子问题的解，直至最终原问题的解
前者即所谓的制表（tabulation）或记忆（memoization）策略
后者即所谓的动态规划（dynamic programming）策略
int pre;
int Fibonacci(int n, int& pre) //计算Fibonacci数列的第n项（线性递归版）
{
if (n == 0) { //若到达递归基，则
pre = 1; //直接取值：Fibonacci(-1) = 1，Fibonacci(0) = 0
return 0;
} else { //否则
int t = pre;
pre = Fibonacci(n-1, t); //递归计算前两项
return (t + pre); //其和即为正解
}
} //用辅助变量记录前一项
//Fibonacci(7, pre) = 13其对应的解答，可借助形式参数的几只，通过pre“调阅”此前的记录直接获得
该算法呈线性递归模式，递归的深度线性正比于输入n，前后共计仅出现O(n)个递归实例，累计耗时不超过O(n)
该算法共需使用O(n)规模的附加空间
反观以上线性递归版Fibonacci()算法可见，其中所记录的每一个子问题的解答，只会用到一次
在该算法抵达递归基之后的逐层返回过程中，每向上返回一层，以下各层的解答均不必继续保留
若将以上逐层返回的过程，等效地视作从递归基出发，按规模自小而大求解各子问题的过程，即可采用动态规划的策略
int Fibonacci(int n) //计算Fibonacci数列的第n项（迭代版）：O(n)
{
int pre = 1, ret = 0; //初始化：Fibonacci(-1)，Fibonacci(0)
while (n > 0) {
ret += pre;
pre = ret - pre;
--n;
}
return ret;
}
这里仅使用了两个中间变量，记录当前的一对相邻Fibonacci数
整个算法仅需线性步的迭代，时间复杂度为O(n)
更重要的是，该版本仅需常熟规模的附加空间，空间效率也有了极大提高
void max2(int A[], int low, int high, int& x1, int& x2) //递归+分治
{
if (low+2 == high) {
x1 = low;
x2 = low+1;
if (A[x1] < A[x2]) {
swap(x1, x2);
}
if (A[x2] < A[high]) {
x2 = high;
if (A[x2] > A[x1]) {
swap(x2, x1);
}
}
return;
} else if (low+3 == high) {
x1 = low;
x2 = low+1;
if (A[x1] < A[x2]) {
swap(x1, x2);
}
for (int i=low+2; i<=high; ++i) {
if (A[i] > A[x2]) {
x2 = i;
if (A[x2] > A[x1]) {
swap(x1, x2);
}
}
}
return;
}
int mid = (low + high) >> 1;
int x1L, x2L;
max2(A, low, mid, x1L, x2L);
int x1R, x2R;
max2(A, mid, high, x1R, x2R);
if (A[x1L] > A[x1R]) {
x1 = x1L;
x2 = (A[x2L] > A[x1R]) ? x2L : x1R;
} else {
x1 = x1R;
x2 = (A[x2R] > A[x1L]) ? x2R : x1L;
}
}选自：
《数据结构（C++语言版）（第三版）》邓俊辉
略有改动
标签：
原文地址：http://blog.csdn.net/only_air/article/details/51211320
