迭代的是人，递归的是神。——L. Peter Deutsch

递归，数学里面叫recursion，其实就是递推关系. 中学数学有一部分其实就是递归的很是典型的作法，不过老师们都没怎么扩展，新课标必修五第二章数列应该算是咱们第一次接触递推的概念了. 
　　其实说到递归，大伙都知道就是本身调本身，这样其实你们都明白，可是说来怎么调？如何控制？又如何看获得结果是想要的呢？相信仍是很晕，下面从中学数学里面来看看吧.

第一部分、两个典型的例子，等差数列与等比数列

　　其实这其实是一个例子，教书的时候我经常会问学生：“什么是等差数列？”固然同窗们都会回答：“就是后一项总比前一项多一个数，这个数不变...”也有的说：“就是后一项减去前一项为必定常数...”
因此咱们常常用表达式表示为
　　a(n)=a(n-1)+d
　　TeX语法为
　　\[a_n=a_{n-1}+d\]
那又有问题了，这里肯定了一个数列没有呢？固然没有，我说后一项比前一项多2，这是什么数列？
是1,3,5,7,9, ...仍是2,4,6,8,10, ...
　　固然弄不清楚，为何呢？由于咱们谈到的数列须要有一个首项，即第一项的值，因此一旦谈到解递推数列，就应该有两个内容，一个是连续项间的关系，另外一个就是首项关系.

那么就能够利用叠加的方法来计算了：
假设这里首项为1，也就是a(1)=1，而这个常数就为2
那么
a(n)=a(n-1)+2
a(n-1)=a(n-2)+2
a(n-2)=a(n-3)+2
a(n-3)=a(n-4)+2
...
a(3)=a(2)+2
a(2)=a(1)+2
将等号左边的依次相加，右边的也依次相加
这样很容易发现，左边有一部分从a(2)一直加到a(n-1)，右边也有一部分从a(2)一直加到a(n-1)，那么消去，就左边剩下a(n)，右边就剩下a(1)和n-1个2相加了，数学公式就成了
a(n)=a(1)+2(n-1)
即
　　a(n)=1+2(n-1)
　　LaTeX代码为
　　\[a_n=1+2(n-1)\]

就是等差数列的通向公式啦，那么这个递推关系中能够看到a(n)=a(n-1)+x即为连续项间的关系，而a(1)=1就是首项啦. 那这个和递归间的关系就很明显啦
a(n)=a(n-1)+x表示，调用a(n)即执行a(n-1)+x，那么同时调用a(n-1),...这样一直下去，最后当a(1)时不在调用函数，直接返回1，再一路加回去，结束递归.

下面看看用代码来实现，仍是假定首项为1，公差为2

#include <stdio.h>

int main()
{
　　 int AddFun(int);
　　 int num;
　　 printf("Please input num:");
　　 scanf("%d",&num);
　　 printf("The result is %d",AddFun(num));
　　 return 0;
}

int AddFun(int n)
{
　　 if(n == 1)
　　 {
　　　　  return 1;
　　 }
　　 return AddFun(n-1) + 2;
}
这里呢AddFun(n)就是以前看到的a(n)，在调用的过程当中先判断n是否为1，若是为1固然就表示如今是首项了，不在继续调用，直接返回结果1
这里使用的不是数学中的公式计算，纯粹的事利用递推关系获得的结果.

再看看等比数列. 相信已经很清楚了，等比数列就是后一项是前一项的定常数被，表示为
　　a(n)=a(n-1)*q
　　LaTeX代码为
　　\[a_n=a_{n-1}\cdot q\]
将函数改一改就能使用了，假设首项为1，公比为2：
int ProductFun(int n)
{
　　 if(n == 1)

　　 {
 　　　　 return 1;
　　 }
　　 return AddFun(n-1)*2;
}

那么留个练习，这但是一道高中数学的典型例题(LaTeX代码)：
已知数列~$\{a_n\}$~知足~$a_n = 2a_{n-1}+1$，且首项~$a_1 = 1$，用递归调用写出代码过程. 
（递推关系为a(n)=2a(n-1)+1，a(1)=1）

参考代码：
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int SumCon(int n);
    printf("%d",SumCon(10));
    return 0;
}

int SumCon(int n)
{
    if(n<=0)
    {
        return 1;
    }
    return 2 * SumCon( n - 1 ) + 1;
}

固然递归不必定要调用函数开完成，使用for循环同样能够作到
好比仍是公比为2，首项为1的等比数列求第10项的值
能够写成
#include <iostream>
using namespace std;
int main()
{
　　 int res = 1;
　　 for(int i=1; i <10; i++)
　　 {
　　　　  res = res * 2;
　　 }
　　 cout<<res<<endl;
　　 return 0;
}
这个同样能够粗略的当作一种递归，res = res * 2表示将前一项的2倍赋值给后一项，也就是说后一项与前一项的2倍相等，不就是递推关系了吗...

第二部分、递归调用注意（直接递归）

　　递归调用在编程里面就是对一个函数，或方法进行本身掉本身，那么在编写递归代码时有三点要注意，首先要注意一个问题，就是递推关系，这里须要抽象出一个递推的关系，不必定只有两层，或许是三层甚至更多

例如：楼梯有n阶台阶,上楼能够一步上1阶,也能够一步上2阶,编一程序计算共有多少种不一样的走法.

先来分析一下，若是只有一个台阶，那么显然只有1种，因此a(1)=1
若是有两个台阶，呢么就有每次上一层，上两次，和一次上两层，即1+1和2共2种，即a(2)=2
当n=3时，那么就有1+1+一、1+二、2+1共3种了，彷佛还看不出规律，那么分析一下递推关系，即先后项间的关系
到达第三层有两个方法，一是从第二层走一步到第三层，那么有a(2)种方法，又能够从第一层走两步到第三层，即a(1)种方法，拍脑壳了，显然到达第三层有a(1)+a(2)种方法，那么是否是呢？验证一下
a(1)+a(2)=1+2=3，咦，正好，看来有点像了，再来看看第四层是否是
当n=4时，按照上边的分析确定为a(2)+a(3)=2+3=5，下面咱们枚举一下：1+1+1+一、1+1+二、1+2+一、2+1+一、2+2，刚恰好，看来就是她了！
那么递推关系就有了，即a(n)=a(n-1)+a(n-2)，同时还有了首项的值：a(1)=1，a(2)=2，因为递推关系有三项，很显然必须有两个初始值

好啦，上面讨论了递归的一个注意，下面是第二个注意，临界条件
既然递归就是本身调本身，那么怎么中止呢，显然不作逻辑判断，计算机会一直运行下去，知道程序崩溃（栈溢出），因此就须要加上一个if判断来跳出递归，其实就是前面提到的数列首项，就是这里的a(1)和a(2)
那么代码就能够这么写了：

int Count(int n)
{
　　 if(2 == n)
　　 {
　　　　  return 2;
 　　}
　　 else if(1 == n)
　　 {
　　　　  return 1;
 　　}
 　　return Count( n - 1 ) + Count( n - 2 );
}
实际上这就是一个典型的Fibonacci数列，只是初始值不一样罢了，下面留两个练习（著名的数列）：
一、反Fibonacci数列，知足的递推关系为：a(n+2)=a(n)-a(n+1)
二、巴都万数列，知足递推关系：a(n)=a(n-2)+a(n-3)

如今剩下第三个要注意的事项了，就是递归体. 
先看两个函数代码(C++代码)：
一、
void Test_1(int n)
{
　　 cout<<n<<endl;
　　 if(n < 6)
　　 {
　　　　  Test_1( n + 1 );
　　 }
}
二、
void Test_2(int n)
{
 　　if(n < 6)
　　 {
　　　　  Test_2( n + 1 );
　　 }
　　 cout<<n<<endl;
}
若是在main()函数中分别调用这两个函数，会有什么执行结果呢？
如今咱们假定n为0
第一个函数打印出
0
1
2
3
4
5
6
第二个函数打印出
6
5
4
3
2
1
0
这个就很奇怪了，这是为何呢？
　　实际上前面咱们考虑的递归关系是单一的递归，可是这两个递归体中，除了完成递归外，还有其余执行代码. 
其实以前也有，只是没有显示出来，就没有被察觉而已
那么怎么去分析呢？
　　其实很简单，递归体自己可分为三个部分，一个是头代码，一个是递归表达式，一个是尾代码，区分头尾的天然就是递归表达式了
看这段代码：
#include <iostream>
using namespace std;
int main()
{
    void Test(int);
    Test(1);
    return 0;
}
void Test(int n)
{
    cout<<n<<endl;
    if(n < 3)
    {
　　　　 Test( n + 1 );
　　　　 cout<<n<<endl;
    }
}
输出结果为
1
2
3
2
1

那么在这段代码中if()前面的输出流为头代码，中间的Test( n + 1 )为递归表达式，这里的尾代码依然是一个输出流
那么分析此程序怎么作呢？很简单，八个字
　　“头尾分开，等待归来”
头尾分开，就是将两个cout<<n<<endl分开，第一个cout<<n<<endl执行，而后转入第一次递归，等待递归结束后回到第二个cout<<n<<endl语句执行
这样说很抽象，咱们一步步分析一下

第一次调用，n=1
执行头cout<<n<<endl，输出1，而且尾cout<<n<<endl等待，其值也是1，但未输出；
进入第一次递归，n=2
执行头cout<<n<<endl，输出2，而且尾cout<<n<<endl等待，其值是2，但未输出；
进入第二次递归，n=3
执行头cout<<n<<endl，输出3，但判断n < 3 不成立，即再也不执行尾cout<<n<<endl语句，函数体结束
回到第一次递归体，执行等待的尾cout<<n<<endl，输出2，第一次递归体结束，会带最外层
执行等待的cout<<n<<endl，输出1，整个函数调用结束，回到main()函数体继续执行其余命令.

　　　形象的说就像是一架手风琴同样，函数调用开始就拉开手风琴，而后进入递归，等待内层递归结束才执行后面的代码
也就八个字“头尾分开，等待归来”
　　其实这就是实现的栈的结构

　　到这里就基本结束了我所理解的递归含义，总结一下：
递归调用即递推关系
递归三个注意：注意递推表达、注意临界判断、注意递归体

 摘自http://www.cnblogs.com/zzdxpq/