递归函数的文章汇集

来源：互联网发布：内衣品牌推荐知乎编辑：程序博客网时间：2024/05/21 21:47

递归函数，是指某一函数内部自己直接或间接地调用自己，即直接递归和间接递归。是语言中比较高级的技术用法。

递归函数之所以难，是因为是一种过于抽象化的技术，写代码的时候无法直观的看出逻辑是否符合自己要求，因此想一次性写好递归函数，是一件很困难的事情，必须要程序运作起来执行递归函数的代码才能看出是否正确，而且进行测试的难度也很高，有时的隐含bug可能要软件上线后才会渐渐体现出来。

笔者写过几次较为复杂的递归函数，总结出了一些写递归函数的技巧和方法，这里特地拿出来给大家分享，如果各位还有更好的想法，欢迎多加指点。

首先，要分析清楚满足递归的条件，并一一列出。

这点十分重要，它是执行递归函数的前提，你写之前就一定要想清楚什么时候（条件）这个函数会自己调自己，为了防止疏漏条件，最好把所有满足递归的条件都列在纸上或者文档上，一定要尽可能的全面。因为我们经常容易漏掉某一种满足条件，那么结果自然就会不正确。

其次，要分析不满足条件时的处理方式。

在列出了所有条件后，我们自然还要考虑不满足条件后的结果，一种是业务本身要求的不满足条件后的处理，另一种就是出现错误时候的处理。说的简单点，就是正确的情景考虑到了后还要考虑错误的情景。

接下来，要分析递归函数的返回值。

如果递归函数有返回值，那么每执行完一次递归函数后，上一递归函数如何接收、处理该递归函数的返回值。

最后，写完递归函数后一定要进行单元测试，测试也要有方法。

因此难以保障一次写完后正确性，所以写完后一定要测试，递归函数本身测试也很麻烦，递归次数少倒还好，递归次数一旦多的话就很头疼。这时我们可以将循环的次数，以及递归的后的结果打印出来，看看打印后的结果是否符合自己的预期，如果某一递归出现问题，可以根据循环次数的记录在调试的时候直接定位，这样效率会高很多，也容易很多，要不然一步步调试看，实在是折磨人。测试的时候一定要涉及到所有满足递归的条件，每一条件分支都要检查一遍，这样才是较为全面的测试递归的方法。

写递归函数，不是一下两下能搞定的事情，本身就是一个反复性工作，编写→测试→编写→测试→...，所以在分析、编写的时候一定要静心、细心，不要急躁，这样渐渐的递归函数也就健全起来。头几次写递归函数可能写不好，日后多多练习便会慢慢深刻体会到递归的精髓。

那么我想说的也说完了，希望这篇文章能对大家有帮助。

递归算法看起来比较简单，当总觉得没能领会到它的精髓，平常也没可以使用它。今天看到这篇文章，说的比较透彻：

1，递归与循环之间的关系

看过这样一道题，问，“程序结构化设计的三种基础结构，顺序、选择、循环是不是必须的？”当然，你知道这样一个论断，只要有这三种就足够了；但是能不能更少呢？答案是“可以”，原因就是递归能取代循环的作用，例如下面的对一个数组里面元素求和的函数：

float rsum (float a, const int n)
{
if (n <= 0) return 0;
else return rsum(a, n – 1) + a;
}

　　实际上就是：

sum = 0;
for (int i = 0; i < n; i++) sum += a;

　　但实际的情况是，任何的一种语言里面都有循环结构，但不是任何的语言都支持递归；套用一句话，递归是万能的，但没有递归不是万万不能的。然而，我看到现在的某些人，不管什么问题都要递归，明明循环是第一个想到的方法，偏偏费尽脑筋去寻找递归算法。对此，我真的不知道该说什么。

------我的理解是，循环和递归是2种结构，能实现类似的功能，至于哪种效率高，很简洁易懂，要具体情况具体分析了。

2，什么时候用递归,是必要的？

从学排列组合那天开始，我所知道的阶乘就是这个样子n! = 1×2×……n。如果让我来写阶乘的算法，我也只会想到从1乘到n。再如，斐波那契数列，如果有人用自然语言描述的话，一定是这样的，开始两项是0、1，以后的每项都是前面两项的和。所以让我写也只会得到“保存前两项，然后相加得到结果”的迭代解法。——现在只要是讲到递归几乎就有他们的登场，美其名曰：“定义是递归的，所以我们写递归算法”。我想问的是，定义的递归抽象是从哪里来的？显然阶乘的定义是从一个循环过程抽象来的，斐波那契数列的定义是个迭代的抽象。于是，我们先从一个本不是递归的事实抽象出一个递归的定义，然后我们说，“因为问题的定义是递归的，因此我们很容易写出递归算法”，接着说，“我们也能将这个递归算法转化为循环、迭代算法”，给人的感觉就像是1÷3＝0.33……，0.33……×3＝0.99……，然后我们花了好大的心智才明白1＝0.99……。

　　还是有那么些人乐此不疲，是凡讲到递归就要提到这两个，结果，没有一个学生看到阶乘那样定义没有疑问的，没有一个对于那个递归的阶乘函数抱有钦佩之情的——瞎折腾什么呢？

————我的理解是，如果一个问题在解决时，被描述/被抽象为前几项的什么什么时（迭代），自然而然就会想到使用递归算法。

3，有效使用递归

我的理解：有些问题用递归的方法来解决，非常合适，一个典型的例子就是汉诺塔。通过下面的使用非递归算法来求解汉诺塔的例子，让我理解到：递归在于在于准确的回归，并且可以有较大的深度（栈）。而人脑的逆推深度是有限的，而计算机要比人脑深很多。这种思维在某种程度上提高了人解决问题的能力！

“但我坚信，如果一个问题能用分析的办法解决——递归实际上就是一个分析解法，能将问题分解成－1规模的同等问题和移动一个盘子，如果这样分解下去一定会有解，最后分解到移动1号盘子，问题就解决了——那么我也应该能用综合的办法解决，就是从当前的状态来确定怎样移动，而不是逆推得到决定。这是对实际工作过程的一个模拟，试想如果让我们去搬盘子，我们肯定不会用递归来思考现在应该怎么搬——只要8个盘子，我们脑子里的“工作栈”恐怕就要溢出了——我们要立即决定怎么搬，而不是从多少步之后的情景来知道怎么搬。下面我们通过模拟人的正向思维来寻找这个解法。

　　假设如下搬7个盘子的初始状态（选用7个是因为我曾经写出了一个1～6结果正确的算法，而在7个的时候才发现一个条件的选择错误，具体大家自己尝试吧），我们唯一的选择就是搬动1号盘子，但是我们的问题是向B搬还是向C搬？

　　显然，我们必须将7号盘子搬到C，在这之前要把6号搬到B，5号就要搬到C，……以此类推，就会得出结论（规律1）：当前柱最上面的盘子的目标柱应该是，从当前柱上“需要搬动的盘子”最下面一个的目标柱，向上交替交换目标柱到它时的目标柱。就是说，如果当前柱是A，需要移动m个盘子，从上面向下数的第m个盘子的目标柱是C，那么最上面的盘子的目标柱就是这样：if (m % 2) 目标和第m个盘子的目标相同（C）;else 目标和第m个盘子的目标不同（B）。接下来，我们需要考虑如果发生了阻塞，该怎么办，如下所示：

　　3号盘子的目标柱是C，但是已经有了1号盘子，我们最直觉的反映就是——将碍事的盘子搬到另一根柱子上面去。于是，我们要做的是（规律2）：保存当前柱的信息（柱子号、应该搬动的最下面一块盘子的号，和它的目标柱），以备当障碍清除后回到现在的柱子继续搬，将当前柱转换为碍事的盘子所在的柱子。假设这样若干步后，我们将7号盘子从A搬到了C，此时，保存当前柱号的栈一定是空了，我们该怎么办呢？

　　显而易见的，转换当前柱为B，把6号盘子搬到C。由此可得出（规律3）：假设当前的问题规模为n，搬动第n个盘子到C后，问题规模减1，当前柱转换到另一个柱子，最下面的盘子的目标柱为C。

　　综上，我们已经把这个问题解决了，可以看出，关键是如何确定当前柱需要移动多少盘子，这个问题请大家自己考虑，给出如下例程，因为没有经过任何优化，本人的编码水平又比较低，所以这个函数很慢——比递归的还慢10倍。

#include
#include

using namespace std;
class Needle
{
public:
Needle() { a.push_back(100); }//每一个柱子都有一个底座
void push(int n) { a.push_back(n); }
int top() { return a.back(); }
int pop() { int n = a.back(); a.pop_back(); return n; }
int movenum(int n) { int i = 1;while (a > n) i++; return a.size() - i; }
int size() { return a.size(); }
int operator (int n) { return a; }
private:
vector a;
};

void Hanoi(int n)
{
Needle needle, ns;//3个柱子，ns是转换柱子时的保存栈，借用了Needle的栈结构
int source = 0, target, target_m = 2, disk, m = n;
for (int i = n; i > 0; i--) needle.push(i);//在A柱上放n个盘子
while (n)//问题规模为n，开始搬动
{
if (!m) { source = ns.pop(); target_m = ns.pop();
m = needle.movenum(ns.pop()); }//障碍盘子搬走后，回到原来的当前柱
if (m % 2) target = target_m; else target = 3 - source - target_m;//规律1的实现
if (needle.top() < needle.top())//当前柱顶端盘子可以搬动时，移动盘子
{
disk = needle.top();m--;
cout << disk << " move " << (char)(source + 0x41) << " to "<< (char)(target + 0x41) << endl;//显示搬动过程

needle.push(needle.pop());//在目标柱上面放盘子
if (disk == n) { source = 1 - source; target_m = 2; m = --n; }规律3的实现
}

else//规律2的实现
{
ns.push(needle.size() - m]);
ns.push(target_m); ns.push(source);
m = needle.movenum(needle.top());
target_m = 3 - source - target; source = target;
}
}
}

　　这个算法实现比递归算法复杂了很多（递归算法在网上、书上随便都可以找到），而且还慢很多，似乎是多余的，然而，这是有现实意义的。我不知道现在还在搬64个盘子的僧人是怎么搬的，不过我猜想一定不是先递归到1个盘子，然后再搬——等递归出来，估计胡子一打把了（能不能在人世还两说）。我们一定是马上决定下一步怎么搬，就如我上面写的那样，这才是人的正常思维，而用递归来思考，想出来怎么搬的时候，黄瓜菜都凉了。正像我们做事的方法，虽然我今生今世完不成这项事业，但我一定要为后人完成我能完成的，而不是在那空想后人应该怎么完成——如果达不到最终的结果，那也一定保证向正确的方向前进，而不是呆在原地空想。

　　由此看出，计算机编程实际上和正常的做事步骤的差距还是很大的——我们的做事步骤如果直接用计算机来实现的话，其实并不能最优，原因就是，实际中的相关性在计算机中可能并不存在——比如人脑的逆推深度是有限的，而计算机要比人脑深很多，论记忆的准确性，计算机要比人脑强很多。这也导致了一个普通的程序员和一个资深的程序员写的算法的速度常常有天壤之别。因为，后者知道计算机喜欢怎么思考。

4，递归的最大缺陷：占用内存多

内容参考：http://bbs.bccn.net/thread-186018-1-1.html

递归算法看起来比较简单，当总觉得没能领会到它的精髓，平常也没可以使用它。今天看到这篇文章，说的比较透彻：

1，递归与循环之间的关系

float rsum (float a, const int n)
{
if (n <= 0) return 0;
else return rsum(a, n – 1) + a;
}

　　实际上就是：

sum = 0;
for (int i = 0; i < n; i++) sum += a;

------我的理解是，循环和递归是2种结构，能实现类似的功能，至于哪种效率高，很简洁易懂，要具体情况具体分析了。

2，什么时候用递归,是必要的？

————我的理解是，如果一个问题在解决时，被描述/被抽象为前几项的什么什么时（迭代），自然而然就会想到使用递归算法。

3，有效使用递归

#include
#include

needle.push(needle.pop());//在目标柱上面放盘子
if (disk == n) { source = 1 - source; target_m = 2; m = --n; }规律3的实现
}

else//规律2的实现
{
ns.push(needle.size() - m]);
ns.push(target_m); ns.push(source);
m = needle.movenum(needle.top());
target_m = 3 - source - target; source = target;
}
}
}

4，递归的最大缺陷：占用内存多

内容参考：http://bbs.bccn.net/thread-186018-1-1.html

递归是许多经典算法的backbone, 是一种常用的高效的编程策略。简单的几行代码就能把一团遭的问题迎刃而解。这篇博客主要通过解决汉诺塔问题来理解递归的精髓。

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

我们首先假设要把n个金片从宝针‘A’移动宝针‘B’，还有有另外一根'V'可以借用。

如果n = 1，那么直接从 A->B 即可。

如果n = 2，那么先把A最上面（第一个）金片移动到V，暂且放一下，然后第二个金片移动到B目的地，接着再把V上面的移动到B目的地，所以移动的次序是 A->V, A->B, V-B。

如果n = 3，可以这么考虑: 先不看出发地A最下面一个最大的金片，先解决怎么把上面两个移走，方法我们已经知道了，但是移到哪里呢？只有B, V可选，B肯定是不行，因为B是目的地，那么只能是通过B先把两个金片移动到V（A->B, A->V, B->V），然后最下面那个最大的金片移动到目的地B（A->B）。注意这时B上面仅有这个最大的金片，A上面空的，V上面有两个金片。接着把V上面两个金片借由A移动到B（V->A, V->B, A->B）。

如果n = 4, 同样的不考虑最大的一个，先把前三个移动到V，使用上面介绍的移动次序。

以此类推（其实 n = 2时，也可以看作是先解决最上面一个的问题，然后才是把最下面的金片移动到目的地）

通过分析，发现解决n个金片的方法是先借由B,把n-1个移动到V，然后把A最下面一个移动到B，在然后借由A把V上面n-1移动到B。

用java实现如下

[java] view plaincopy
// in java  
public class Hanoi{  
    private static int count = 0;  
    public static void move(char src, char des, int n){  
        System.out.println("plate:"+ src +" pillar"+"->"+des+" pillar");  
        count++;  
  
  
    }  
  
    public static void hanoiSolver(char src, char via, char des, int n){  
        if (n==1){  
            move(src, des, n);  
        } else{  
            hanoiSolver(src, des, via, n-1);  
            move(src, des, n);  
            hanoiSolver(via, src, des, n-1);  
        }  
    }  
  
    public static void main(String[] args) {  
        char src = 'A'; //source pillar  
        char des = 'B'; //detination pillar  
        char via = 'V'; //via pillar  
        int n = 3;// the numer of plates  
        hanoiSolver(src, via, des, n);  
        System.out.println("the total number of moves is "+count);  
    }  
}  

仔细分析这个算法，可以学习到：

1. 初中高中大学数学解题中常常用到的归纳总结。一个看似复杂至极的问题，先心里不要慌，初步分析前面几个，看到规律，推而广之。

2. 计算过程中的调用自身函数，形成重入，并因此而把复杂问题化解为相对简单或已经知道答案的小问题。这也不经我想到解数列题的各种方法。（对不起，高中是博主学习数学最认真的时候）

3. 在递归中必须有明确递归结束条件称递归出口，否则就是死循环啦。如本问题中当n=1时，就是退出递归的时候。

故事中所说的如果成功得把金片移动结束，世界就灰飞烟灭，这是真的吗？我们来小研究下：

假设f(n)为n个盘子要移动的次数。
那么根据上面分析 f(n + 1) = f(n) + 1 +f(n) = 2*f(n)+1

变换为 [f(n + 1) + 1] = 2*[f(n) + 1]，经典等比数列
因为f(1) = 1，所以可得f(n) = 2^n - 1。

f(64)= 2^64-1，

所以一共要移动 2^64-1次, 假使一秒钟移动一次，不吃不睡觉，一共要移动2.1350398e+14天，584,942,417,355年。

Take-away Tip:

递归Recursive 就是在程序中调用自身，形成重入，把复杂问题层层简化成一个已然解决的问题，

并在一定条件下退出递归。

递归算法看起来比较简单，当总觉得没能领会到它的精髓，平常也没可以使用它。今天看到这篇文章，说的比较透彻：

1，递归与循环之间的关系

float rsum (float a, const int n)
{
if (n <= 0) return 0;
else return rsum(a, n – 1) + a;
}

　　实际上就是：

sum = 0;
for (int i = 0; i < n; i++) sum += a;

------我的理解是，循环和递归是2种结构，能实现类似的功能，至于哪种效率高，很简洁易懂，要具体情况具体分析了。

2，什么时候用递归,是必要的？

————我的理解是，如果一个问题在解决时，被描述/被抽象为前几项的什么什么时（迭代），自然而然就会想到使用递归算法。

3，有效使用递归

#include
#include

needle.push(needle.pop());//在目标柱上面放盘子
if (disk == n) { source = 1 - source; target_m = 2; m = --n; }规律3的实现
}

else//规律2的实现
{
ns.push(needle.size() - m]);
ns.push(target_m); ns.push(source);
m = needle.movenum(needle.top());
target_m = 3 - source - target; source = target;
}
}
}

4，递归的最大缺陷：占用内存多

内容参考：http://bbs.bccn.net/thread-186018-1-1.html

0 0