替换递归的算法

㈠ 什么是递归算法

递归算法就是一个函数通过不断对自己的调用而求得最终结果的一种思维巧妙但是开销很大的算法。
比如：
汉诺塔的递归算法：
void move(char x,char y){
printf("%c-->%c\n",x,y);
}

void hanoi(int n,char one,char two,char three){
/*将n个盘从one座借助two座，移到three座*/
if(n==1) move(one,three);
else{
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
}
}

main(){
int n;
printf("input the number of diskes:");
scanf("%d",&n);
printf("The step to moving %3d diskes:\n",n);
hanoi(n,'A','B','C');
}
我说下递归的理解方法
首先：对于递归这一类函数，你不要纠结于他是干什么的，只要知道他的一个模糊功能是什么就行，等于把他想象成一个能实现某项功能的黑盒子，而不去管它的内部操作先，好，我们来看下汉诺塔是怎么样解决的
首先按我上面说的把递归函数想象成某个功能的黑盒子，void hanoi(int n,char one,char two,char three); 这个递归函数的功能是：能将n个由小到大放置的小长方形从one 位置，经过two位置 移动到three位置。那么你的主程序要解决的问题是要将m个的"汉诺块"由A借助B移动到C，根据我们上面说的汉诺塔的功能，我相信傻子也知道在主函数中写道：hanoi(m,A,B,C)就能实现将m个块由A借助B码放到C，对吧？所以，mian函数里面有hanoi(m,'A','C','B');这个调用。
接下来我们看看要实现hannoi的这个功能，hannoi函数应该干些什么？
在hannoi函数里有这么三行
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
同样以黑盒子的思想看待他，要想把n个块由A经过B搬到C去，是不是可以分为上面三步呢？
这三部是：第一步将除了最后最长的那一块以外的n-1块由one位置经由three搬到two 也就是从A由C搬到B 然后把最下面最长那一块用move函数把他从A直接搬到C 完事后 第三步再次将刚刚的n-1块借助hannoi函数的功能从B由A搬回到C 这样的三步实习了n块由A经过B到C这样一个功能，同样你不用纠结于hanoi函数到底如何实现这个功能的，只要知道他有这么一个神奇的功能就行
最后：递归都有收尾的时候对吧，收尾就是当只有一块的时候汉诺塔怎么个玩法呢？很简单吧，直接把那一块有Amove到C我们就完成了，所以hanoni这个函数最后还要加上 if(n==1)move(one,three);（当只有一块时，直接有Amove到C位置就行）这么一个条件就能实现hanoin函数n>=1时将n个块由A经由B搬到C的完整功能了。
递归这个复杂的思想就是这样简单解决的，呵呵 不知道你看懂没？纯手打，希望能帮你理解递归
总结起来就是不要管递归的具体实现细节步骤，只要知道他的功能是什么，然后利用他自己的功能通过调用他自己去解决自己的功能（好绕口啊，日）最后加上一个极限情况的条件即可，比如上面说的1个的情况。

㈡ 递归算法的介绍

递归算法是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数（或过程）来表示问题的解。一个过程(或函数)直接或间接调用自己本身,这种过程(或函数)叫递归过程(或函数).

㈢ 常见算法1——递归算法

递归算法就是通过自身不断反复调用自身以解决问题，其中最经典的也就是汉诺达和斐波纳契数列的问题了。
1.汉诺塔问题
在印度，有这么一个古老的传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的64片金片，这就是所谓的汉诺塔。不论白天黑夜，总有一个僧侣在按照下面的法则移动这些金片，一次只移动一片，不管在哪根针上，小片必在大片上面。当所有的金片都从梵天穿好的那根针上移到另外一概针上时，世界就将在一声霹雳中消灭，梵塔、庙宇和众生都将同归于尽。

分析：挪到C的金片也是从下到上由大到小的顺序排列，那么A之剩下最下面的金片移动到C的时候，C上面是不可以有金片的，这个时候A上面只有第n个金片，B上面有n-1个金片，C上面没有金片，然后这个情况就和刚开始情况相同了，只不过A和B颠倒了位置而已。
（1）n-1个金片从A通过C移动到B，n-1个金片从A通过C移动到B也是不断调用自身逐步缩小范围。通过递归调用后，就完成了A上面仅剩下最大的金片，C上面没有金片，B上面有n-1个金片。
（2）最大的那个金片从A移动到C
（3）调用自身重复刚开始的情况，只不过现在有金片的是B，即B通过A把金片移动到C。

2.斐波纳契数列
2.1生兔子问题
古典问题：3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？下面先从小到大分析下这个情况
分析：假设将兔子分为小中大三种，兔子从出生后从第三个月开始每个月就会生出一对兔子，也就是一旦兔子变为大兔子那么他就生了一对兔子
分析情况图如下

很明显这个是一个为斐波那契数列，即如果用f(n)表示第n个月的兔子的对数，那么f(n)=f(n-1)+f(n-2)

2.2走台阶问题
一个台阶总共有n级，如果一次可以跳1级，也可以跳2级。求总共有多少总跳法，并分析算法的时间复杂度。
分析：假设我们现在还有最后一步要走，可能的情况有哪些？
（1）我们站在第9级上，一步1级后到达顶端；
（2）我们站在第8级上，一步2级后到达顶端；
所以，最后一步可以走1级或者2级，不外乎两种情况。
再假设，已知从0级到9级的走法有M种，从0级到8级的走法有N种，那么从0到10级的走法和M、N有什么关系呢？从0到10级的走法一共是多少种呢？答案是M+N。
所以逐步递归，说白了，这还是个Fibnacci数列。即f(n)=f(n-1)+f(n-2)，事件复杂度是2^n

台阶问题的变种:
一个台阶总共有n级，如果一次可以跳1级，也可以跳2级.....也可以跳n级。求总共有多少总跳法

分析：用Fib(n)表示跳上n阶台阶的跳法数。如果按照定义，Fib(0)肯定需要为0，否则没有意义。但是我们设定Fib(0) = 1；n = 0是特殊情况，通过下面的分析就会知道，强制令Fib(0) = 1很有好处。因为Fib(0)等于几都不影响我们解题，但是会影响我们下面的分析理解。

当n = 1 时， 只有一种跳法，即1阶跳：Fib(1) = 1;

当n = 2 时， 有两种跳的方式，一阶跳和二阶跳：Fib(2) = 2;

到这里为止，和普通跳台阶是一样的。

当n = 3 时，有三种跳的方式，第一次跳出一阶后，对应Fib(3-1)种跳法； 第一次跳出二阶后，对应Fib(3-2)种跳法；第一次跳出三阶后，只有这一种跳法。Fib(3) = Fib(2) + Fib(1)+ 1 = Fib(2) + Fib(1) + Fib(0) = 4;

当n = 4时，有四种方式：第一次跳出一阶，对应Fib(4-1)种跳法；第一次跳出二阶，对应Fib(4-2)种跳法；第一次跳出三阶，对应Fib(4-3)种跳法；第一次跳出四阶，只有这一种跳法。所以，Fib(4) = Fib(4-1) + Fib(4-2) + Fib(4-3) + 1 = Fib(4-1) + Fib(4-2) + Fib(4-3) + Fib(4-4) 种跳法。

当n = n 时，共有n种跳的方式，第一次跳出一阶后，后面还有Fib(n-1)中跳法； 第一次跳出二阶后，后面还有Fib(n-2)中跳法..........................第一次跳出n阶后，后面还有 Fib(n-n)中跳法。Fib(n) = Fib(n-1)+Fib(n-2)+Fib(n-3)+..........+Fib(n-n) = Fib(0)+Fib(1)+Fib(2)+.......+Fib(n-1)。

通过上述分析，我们就得到了通项公式：

因此，有 Fib(n-1)=Fib(0)+Fib(1)+Fib(2)+.......+Fib(n-2)

两式相减得：Fib(n)-Fib(n-1) = Fib(n-1) =====》 Fib(n) = 2*Fib(n-1) n >= 3

这就是我们需要的递推公式：Fib(n) = 2*Fib(n-1) n >= 3

㈣ 试将折半查找的算法改为递归算法

if(l>=h)
printf("Not
find
%d.\n",y);
我这里改成>=就行了。。。
你的程序的做法是，通过对比起始两个位置是否相同，来决定是否退递归。
但是，考虑
l==h-1
的情况。。。
(l+h)/2结果为l
，然后若当前位置的数不等，下层递归中，l>h，则永远不会达到退递归的条件。。。

㈤ 《算法导论》三种解递归式的方法

代入法可以用来确定一个递归式的上界或下界。这种方法很有效，但只能用于解的形式很容易猜的情形。

例如，我们需要确定下面递归式的上界：

该递归式与归并排序相似，我们可以猜测其解为

代入法要求证明，恰当选择常数 c>0，可有 T(n)≤cn lgn。首先假设此上界对所有正数 m<n 都成立，特别是对于 m=n/2，有 T(n/2)≤c(n/2)lg(n/2)。将其代入递归式，得到：

其中，只要 c≥1，最后一步都会成立。

并不存在通用的方法来猜测递归式的正确解，但总有一些试探法可以帮助做出好的猜测：

如果某个递归式与先前见过的类似，则可猜测该递归式有类似的解。如，递归式

看起来比较难解，因为右式 T 的自变量中加了 17，但我们可以猜测这个多出来的项对解的影响不大，因为当 n 很大时， 与 之间的差别并不大，两者都将 n 分成均匀的两半。

另一种方法是先证明递归式的较松的上下界，然后再缩小不确定性区间。例如，对递归式 ，因为递归式中有 n，而我们可以证明初始上界为 。然后，逐步降低其上界，提高其下界，直到达到正确的渐近确界 。

有时，我们或许能够猜出递归式解的渐近界，但却会在归纳证明时出现一些问题。通常，问题出在归纳假设不够强，无法证明其准确的界，遇到这种情况时，可以去掉一个低阶项来修改所猜测的界，以使证明顺利进行。如下面的递归式：

可以猜测其解为 ，即要证明对适当选择的 c，有 。有所猜测的界对递归式做替换，得到

由此无法得到 ，无论 c 的值如何。如果猜测一个更大的界，如 ，虽然这确实是上界，但事实上，所猜测的解 却是正确的。为了证明这一点，要做一个更强的归纳假设。

从直觉上说，猜测 几乎是正确的，只是差了一个常数 1，即一个低阶项，然而，就因为差了一项，数学归纳法就无法证明出期望的结果。从所作的猜测中减去一个低阶项，即 是个常数。现在有

只要 b≥ 1。这里，c 要选的足够大，以便能处理边界条件。

你可能会觉得从所作的猜测中减去一项有点儿与直觉不符。为什么不是增加一项来解决问题呢？关键在于要理解我们是在用数学归纳法：通过对更小的值作更强的假设，就可以证明对某个给定值的更强的结论。

在运用渐近表示时很容易出错。例如，对递归式 ，由假设 ，并证明

就是错误的，因为 c 是常数，因而错误地证明了 。错误在于没有证明归纳假设的准确形式，即 。

有时，对一个陌生的递归式作一些简单的代数变换，就会使之变成读者较熟悉的形式。如下例子：

这个式子看上去比较难，但可以对它进行简化，方法是改动变量。为了方便起见，不考虑数的截取整数问题，如将 化为整数。设 ，得

再设 ，得到新的递归式

这个式子看起来与 就非常像了，这个新的递归式的界是： 。将 带回 ，有 。

有时候，画出一个递归树是一种得到好猜测的直接方法。在递归树中，每一个节点都代表递归函数调用集合中一个子问题的代价。将树中每一层内的代价相加得到一个每层代价的集合，再将每层的代价相加，得到的结果是所有层次的总代价。当用递归式表示分治算法的运行时间时，递归树的方法尤其有用。

递归树最适合用来产生好的猜测，然后用代入法加以验证。但使用递归树产生好的猜测时，通常可以容忍小量的“不良量”，因为稍后就会证明所做的猜测。如果画递归树时非常地仔细，并且将代价都加了起来，那么就可以直接用递归树作为递归式的解的证明。

在讲述例子之前，我们先来看一个几何级数公式

对于实数 x≠1，式

是一个几何级数（或称指数级数），其值为

当和是无限的且 |x|<1 时，有无限递减几何级数

我们以递归式

为例来看一下如何用递归树生成一个好的猜测。首先关注如何寻找解的一个上界，因为我们知道舍入对求解递归式通常没有影响（此处即是我们需要忍受不精确的一个例子），因此可以为递归式

创建一颗递归树，其中已将渐近符号改写为隐含的常数系数 c>0。

构造的递归树如下：

求所有层次的代价之和，确定整棵树的代价：

最后的这个公式看起来不够整洁，但我们可以再次充分利用一定程度的不精确，并利用无限递减几何级数作为上界。回退一步，得到：

此时，我们得到了递归式的一个猜测，在上面的例子里， 系数形成了一个递减的等比级数，可知这些系数的总和的上界是常数 。由于树根所需的代价为 ，所以根部的代价占总代价的一个常数部分。换句话说，整棵树的总代价是由根部的代价所决定的。

事实上，如果 确实是此递归式的上界，那么它一定是确界，为什么呢？第一个递归调用所需要的代价是 ，所以 一定是此递归式的下界。

现在我们可以使用代换法来验证猜测的正确性， 是递归式 的一个上界。只需要证明，当某常数 d>0， 成立。适用与前面相同的常数 c>0，有

只要 d≥ ，最后一步都会成立。

上图是递归式

对应的递归树。我们还是使用 c 来代表 项常数因子。当将递归树内各层的数值加起来时，可以得到每一层的 cn 值。从根部到叶子的最长路径是 。因为当 时， ，所以树的深度是 。

直觉上，我们预期递归式的解至多是层数乘以每层的代价，也就是 。总代价被均匀地分布到递归树内的每一层上。这里还有一个复杂点：我们还没有考虑叶子的代价。如果这棵树是高度为 的完整二叉树，那么有 个叶子节点。由于叶子代价是常数，因此所有叶子代价的总和为 ，或者说 。然而，这棵递归树并不是完整的二叉树，少于 个叶子，而且从树根往下的过程中，越来越多的内部结点在消失。因此，并不是所有层次都刚好需要 cn 代价；越靠近底层，需要的代价越少。我们可以计算出准确的总代价，但记住我们只是想要找出一个猜测来使用到代入法中。让我们容忍这些误差，而来证明上界为 的猜测是正确的。

事实上，可以用代入法来证明 是递归式解的上界。下面证明 ，当 d 是一个合适的正值常数，则

上式成立的条件是 。因此，没有必要去更准确地计算递归树中的代价。

主方法给出了求解递归式的“食谱”方法，即将规模为 n 的问题划分为 a 个子问题的算法的运行时间，每个子问题规模为 ，a 和 b 是正常数。a 个子问题被分别递归地解决，时间各为 。划分原问题和合并答案的代价由函数 描述。

从技术正确性角度来看，递归式实际上没有得到很好的定义，因为 可能不是一个整数。但用 向上取整或向下取整来代替 a 项 并不影响递归式的渐近行为，因而，在写分治算法时略去向下取整和向上取整函数会带给很大的方便。

其中我们将 n/b 解释为 n 除以 b 的向下取整或向上取整。那么 T(n) 有如下渐近界：

在使用主定理之前，我们需要花一点时间尝试理解它的含义。对于三种情况的每一种，将函数 f(n) 与函数 进行比较。直觉上，两个函数较大者决定了递归式的解。若函数 更大，如情况 1，则解为 T(n)= ( )。若函数 f(n) 更大，如情况 3，则解为 T(n)= (f(n))。若两个函数大小相当，如情况 2，则乘上一个对数因子，解为 T(n)= ( )= ( )。

另外还有一些技术问题需要加以理解。在第一种情况下，不仅要有 小于 ，还必须是多项式地小于，也就是说， 必须渐近小于 ，要相差一个因子 ，其中 是大于 0 的常数。在第三种情况下，不是 大于 就够了，而是要多项式意义上的大于，而且还要满足“正则”条件 。

注意：三种情况并没有覆盖所有可能的 f(n)。当 f(n) 只是小于 但不是多项式地小于时，在第一种情况和第二种情况之间就存在一条“沟”。类似情况下，当 f(n) 大于 ，但不是多项式地大于时，第二种情况和第三种情况之间就会存在一条“沟”。如果 f(n) 落在任一条“沟”中，或是第三种情况种规则性条件不成立，则主方法就不能用于解递归式。

使用主方法很简单，首先确定主定理的哪种情况成立，即可得到解。

例如：

对于这个递归式，我们有 a=9，b=3，f(n)=n，因此 = = 。由于 f(n) = ，其中 ， 因此可以应用于主定理的情况 1，从而得到解 T(n) = Θ( ) 。

现在考虑

其中，a = 1， b = 3/2， f(n) = 1，因此 = = = 1 。由于 f(n) = = Θ(1) ，因此可应用于情况2，从而得到解 T(n) = Θ( ) 。

对于递归式

我们有 a = 3，b = 4，f(n) = nlgn，因此 = =O( )。由于 当 n，其中 ，因此，如果可以证明正则条件成立，即应用于情况 3。当 n 足够大时，对于 ， ，因此，由情况 3，递归式的解为 T(n)= ( )。

主方法不能用于如下递归式：

虽然这个递归式看起来有恰当的形式：a=2，b=2， ，以及 。你可能错误地认为应该应用情况 3，因为 渐近大于 。问题出现在它并不是多项式意义上的大于。对任意正常数 ，比值 都渐近小于 。因此，递归式落入了情况 2 和情况 3 之间的间隙。

证明分为两部分。第一部分分析“主”递归式 ，并作了简化假设 仅定义在 b>1 的整数幂上，即 ， ， ，…。这部分从直觉上说明该定理为什么是正确的。第二部分说明如何将分析扩展至对所有的正整数 n 都成立，主要是应用数学技巧来解决向下取整函数和向上取整函数的处理问题。

取正合幂时的证明

对于递归式

此时的假设是 n 为 b>1 的正合幂，且 b 不必是整数。分析可分成三个引理说明，第一个引理是将解原递归式的问题归约为对一个含和式的求值的问题。第二个引理决定含和式的界，第三个引理把前两个合在一起，证明当 n 为 b 的正合幂时主定理成立。

引理一 ：设 a≥1，b>1 为常数，f(n) 为定义在 b 的正合幂上的非负函数。定义 如下：

其中 i 是正整数，则有

证明：如下图。根节点代价为 f(n)，它有 a 个子女，每个代价是 。（为方便起见可将 a 视为整数，但这对数学推导没什么影响。）每个子女又各有 a 个子女，代价为 。这样就有 个结点离根的距离为 2。一般地，距根为 j 的结点有 个，每一个的代价为 。每一个叶结点的代价为 ，每一个都距根 ，因为 。树中共有 个叶结点。

可以将树中各层上的代价加起来而得到方程 ，第 j 层上内部结点的代价为 ，故各层内部结点的总代价和为

在其所基于的分治算法中，这个和值表示了将问题分解成为子问题并将子问题的解合并时所花的代价，所有叶子的代价（即解 个规模为 1 的子问题的代价）为 。

根据递归树，主定理的三种情况对应于树中总代价的三种情况：1、由所有叶子节点的代价决定；2、均匀分布在各层上；3、由根结点的代价决定。

引理二 ：设 a≥1，b≥1 为常数， 为定义在 b 的整数幂上的非负函数。函数 由下式定义

对 b 的整数幂，该函数可被渐近限界为：

证明：对情况 1，有 ，这隐含着 。用它对方程 做代换，得

对 O 标记内的式子限界，方法是提出不变项并作简化，得到一个上升几何级数：

因为 b 与 都是常数，最后的表达式可化简为 。用此表达式对 作替换，得

情况 1 得以验证。

为证情况 2，假设 ，有 。用此式对方程 作替换，得

对 记号中的式子做类似情况 1 中的限界，但所得并非是几何级数，而是每项都是相同的:

用此方程对 中的和式做替换，有

则情况 2 得以验证。情况 3 也可以用类似的方式证明。

引理三 ：设 a≥1，b>1 是常量， 是定义在 b 的整数幂上的非负函数。定义 T(n) 如下：

其中 i 是正整数。对于 b 的整数幂，T(n) 可有如下渐近界：

证明：用引理二给出的界来对引理一中的式 求值。对情况 1 有

对情况 2 有

对情况 3 有

㈥ 求大神帮忙写个下面递归算法的替代算法

java">importjava.io.File;
importjava.util.ArrayList;

publicclassListFile{
//递归
	(StringsourceDir){
		Filefile=newFile(sourceDir);
		if(file.isDirectory()){
		for(Fileeach:file.listFiles()){
		processFilePath(each.getAbsolutePath());
		}
		}elseif(file.getAbsolutePath().endsWith(".java")){
		System.out.println(file.getAbsolutePath());
		}
		}
//非递归
	Ex(StringsourceDir){
		ArrayList<File>list=newArrayList<File>();
		list.add(newFile(sourceDir));
		while(!list.isEmpty())
		{
			Filefile=list.remove(0);
			if(file.isDirectory()){
				for(Fileeach:file.listFiles()){
					list.add(each);
				}
				}elseif(file.getAbsolutePath().endsWith(".java")){
				System.out.println(file.getAbsolutePath());
				}
		}		
		}
	
publicstaticvoidmain(String[]args){
	Stringdir="F:\workspace\java";
	processFilePath(dir);
	processFilePathEx(dir);
}
}

㈦ java版递归算法实现单链表的求长度、查找、替换等操作

首先，你实现链表的时候肯定是有一个变量记录链表大小的，求长度，直接获取链表大小就可以。
查找：有两种，一种是下标查找，还有一种是对象查找。其实底层归根结底都是用的index下标查找。 替换也是同道理。你要明白链表的原理，我相信你就不会问递归去做这些操作。
因为你查找只要给出下标，直接在for循环在0到你给定的下标内循环就能取到，如果你给的下标在链表大小/2 的后半部分，你可以倒序循环；当然这只是一种思路，希望能帮到你

㈧ Python 哪些可以代替递归的算法

递归方法有些时候是不太好理解，不过递归的意义就是把解决问题n变成解决n-1的问题，最终变成解决1个问题。 假设有n个盘子，从上到下依次编号，最下面的盘子编号是大写的N。

㈨ C扫雷编程算法中， 能否用循环代替递归实现连续翻图

一般来讲，递归调用可以处理的算法，通过循环去解决常需要额外的低效处理 。扫雷没写过，算法不清楚，直觉~~这个可以有~哈哈

㈩ 有没有好的算法可以代替递归的无限级树结构

A 栈 这里的栈即是指堆栈，是一种先进后出的数据结构。系统实现递归时，本身也是用堆栈实现的，用来保存现场信息。