递归函数

如果你指的这个变量是递归函数中的局部变量或形参，它们是不同的变量，它们是在内存堆栈中具有不同空间的，所以每次调用，它们的值是独立的。

不会555也教教我啊

int Sum(int N){if(N=1) return N;else return Sum(N-1)+N;}

关于递归函数的说法中，不正确的是（） A.递归函数可以改写为非递归函数B.递归函数应有递归结束的条件C.解决同一个问题的递归函数的效率比非递归函数的效率要高D.递归函数往往更符合人们的思路，程序更容易理解正确答案：C

可以都是哈,几行代码就可以当你写的十几行for循环代码.很意思也和复杂

这怎么递归，你题意没说完整吧。

1 引言递归程序处理的问题可以分成两类：第一类是数学上的递归函数，要求算得一个函数值，例如阶乘函数和Fibonacci函数；第二类问题具有递归特征，目的可能是求出满足某种条件的操作序列，例如Hanoi塔和八皇后问题。第一类问题的程序设计是简单的、机械的，而第二类问题则不然，由于涉及面广，没有统一的规则可循，所以编程过程往往比较复杂，而且编得的程序也不大好理解。究其原因在于，第一类问题已经有了现成的函数公式，第二类则没有。如果我们对于第二类问题也能写出它的递归公式，那么编码过程会大大简化，而且还可以改善程序的可读性。本文将借助两个程序实例讨论这种方法。2 公式化方法程序设计可以分成两个阶段：逻辑阶段和实现阶段。逻辑阶段要确定算法，不必考虑编程语言和实现环境。通常算法可以用自然语言、流程图、NS图等工具来表示，对于第二类问题能在逻辑阶段得出它的递归公式，那么至少有这样几个好处：1. 把逻辑阶段同实现阶段截然分开，大大简化程序设计。2. 用数学方法推导递归公式，要比用其他方法设计算法要简单得多。3. 由于公式是算法的最精确最简洁的描述形式，有了递归公式，编码工作就变得异常简单，而且程序的可读性也会很好。所谓递归程序设计的公式化方法，首先要把问题表示成数学意义下的递归函数，那么关键是确定函数值的意义，尽管问题本身未必需要计算什么函数值。函数值的选取可能不是唯一的，但是愈能表现问题本质愈好。Hanoi塔问题要求显示为把若干个盘子从一柱搬到另一柱要采取的动作，我们可以把动作的个数取为函数值。于是得到有四个自变量的递归函数h(d，f，t，u)，其意义是以u柱（using）为缓冲把d个盘子（disks）从f柱（from）搬到t柱（to）。容易得到下面的递归公式：h(1,f,t,u)=1h(d,f,t,u)= h(d-1,f,u,t)+ h(1,f,t,u)+ h(d-1,u,t,f), 如果d>1其实际意义非常明显：搬动一个盘子只需一个动作；而把f柱上的d个盘子从f柱搬到t柱，需要先把上面的d-1个盘子从f柱搬到u柱，再把最下面的一个盘子从f柱搬到t柱，最后把已在u柱上的d-1盘子搬到t柱，因此总的动作个数等于三组动作之和。有了递归公式，编程就变得极为简单。程序的结构是一个多分支结构，恰好同递归公式一一对应，编程几乎变成了机械的翻译。在下面的程序中，递归函数与递归公式的差别只有当d为1时不仅要把动作个数v置为1，同时还要显示此动作。main(){ int d,v,h(int,int,int,int);printf("disks = ");scanf("%d",&d);v=h(d,1,2,3);printf(" %d actions for %d disks! ",v,d);}int h(int d,int f,int t,int u){ int i,v;if(d==1)else v=h(d-1,f,u,t)+h(1,f,t,u)+h(d-1,u,t,f);return v;}此程序的运行会话如下：disks = 31->2 1->3 2->3 1->2 3->1 3->2 1->27 actions for 3 disks!3 例子：八皇后问题八皇后问题[2]是一个更有代表性更复杂的递归例题，要求在8×8的国际象棋棋盘上摆放8个皇后，使她们不致互相攻击。我们采取的算法仍然是从棋盘第一行开始每行放一个皇后，对于每一行都从该行的第一列开始放置，并判断它同前面的那些皇后是否互相攻击，如是就换成下一列，否则继续放置下一个皇后，直至放好8个皇后。依照这种思想，我们定义一个有9个自变量的函数:q（k,a1,a2,a3,a4,a5,a6,a7,a8）其中k表示已放置的皇后个数，而ai（此处i<=k）表示第i行上的皇后所在列的列号，因此这9个自变量能够代表求解过程中任一时刻的状态，而函数值定义为从此状态出发能得到的解的个数。按照这一思想不难得到下面的递归公式：q（k,a1,...,ak,0,...0）= 0 如果有0<i<k,使ai同ak不相容q（k,a1, ... , a8）= 1 如果对于任意的0<i<8,ai同a8都相容q（k,a1,...,ak,0,...0）= q(k+1,a1,...,ak,1,...0）+...+q(k+1,a1,...,ak,8,...,0）如果k<8而且对于任意的0<i<k,ai同ak都相容公式中的“a i和a k相容”的意思是它们不互相攻击，即逻辑表达式：(ai-ak)&&(i+ai-k-ak)&&(i-ai-k+ak)为真，就是说ai≠ak且i+ai≠k+aki且i-ai≠k-ak。将上面的递归公式很容易地翻译成如下程序：main(){ int a[9],v,q(int,int *);v=q(0,a);printf(" There are %d solutions! ",v);}int q(int k,int *a){ int i,u,v;for(i=1,u=1;i<k&&u;i++)u=u&&(a[i]-a[k])&&(i+a[i]-k-a[k])&&(i-a[i]-k+a[k]);if(u==0) v=0;else if(k==8){ v=1; printf("%d%d%d%d%d%d%d%d ",a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);}elsefor(i=1,v=0;i<=8;i++)return v;}递归公式中的自变量a1,…,a8是一个相关的序列，在程序中只好用数组a表示。在q( )中首先计算ak是否同其前的所有ai相容，若是变量u非0。q( )与递归公式严格对应，呈现出有三个选择的分支结构。在u非0且k为8的情况下，置函数值v为1，并显示已得到的解。显然这个程序编写起来最为简单，而且最好理解。下面给出该程序的交互会话，为节省版面只列出92个解中的4个：15863724 16837425 ... 83162574 84136275There are 92 solutions!4 结束语公式化方法是一种简单而有效的设计思想，它把程序设计和程序理解的难点都集中到递归公式上。从上面的例子可以看到这种思想能够简化程序设计，而且得到的程序显然好于通常的程序。这种思想有普遍性，至少适用多数递归程序的设计。由递归公式设计出的程序具有标准的分支结构，编写和理解都要简单得多。上面的两个例题在求得函数值的同时，很容易地得到了要求的序列，但对于一般的问题未必总是这样。笔者曾给出一种伴随序列法，可以用来得到某些问题（如显示所有从m个数中取n个数的组合）要求的序列。

题目是不是写错了啊，这样算出的g（3）不是整数。解体思路可以告诉你，首先令m(t)=3*2^(t-1)-2,这个式子就化成g(t)=(3m+4)/m*g(t-1)+6(m+2)/m*g(t-2)-8(m+2)^2/[m(m-2)]*g(t-3)+4(5m+1)(m+1)/m两边同乘m(t)(m(t)-2),得到m(m-2)g(t)=(3m+4)(m-2)*g(t-1)+6(m+2)(m-2)*g(t-2)-8(m+2)^2*g(t-3)+4(5m+1)(m+1)(m-2)注意到m[t]=2m[t-1]+2=4m[t-2]+6=8m[t-3]+14令g(t)=Am(t)^3+Bm(t)^2+Cm(t)+D带入后，,将所有m[t]划为m[t-3]后整理为以m[t-3]为变量的多项式,令所有项的系数为0即可解得A,B,C,D从常数项可知D=-1/8，但是m(t)应该都是整数，所以是不是题目有问题啊

不明不白。递归函数典型应用例题书上就有一个啊。就是老和尚搬碟子的问题。可以参照一下

你所贴程序中，函数p不是递归函数。递归函数是自己调用自己，遇到结束条件后向前层层返回。double legendre(int n, int x){ if (n == 0) return 1; // 结束条件 if (n == 1) return x; return ((2*n-1)*x - legendre(n-1,x) - (n-1)*legendre(n-2,x)) / n; // 递归，降阶}

这个是不可以的，除非强制退出整个程序的执行，比如使用exit(0);这样的语句。C语言的函数调用是一层一层的，本层函数执行完会返回上一层函数执行，如果一个递归函数已经调用了10层了，不可能说支持退出这十层函数的执行，直接返回最上层的函数，这个是不现实的。但是也可以使用其他方法，比如全局变量之类的，每个函数都去判断这个全局变量，这样只要不满足，一层一层的退出函数，也可以实现这个功能，代码举例如下：int flag=0; //全局变量，判断递归函数是否退出。void fun1()   //递归函数实现{    xxxx    //其他语句    fun1(); //递归调用    if(flag==1)  //判断是否退出    {        return;    }    xxxx    //其他语句    if(xxxx)  //需要退出递归函数的条件    {        flag=1;  //设置标志        return;  //退出，这样会一直退出所有递归函数    }}

是要举个例子？比如：void show(int a){ if(a < n) { a ++; show(a); }}这只是个例子，不用在意里面参数，就是说在一个函数中调用它本身，这个没有写循环，但是通过自身的调用实现了循环的效果

对递归函数中的某一关键变量设置阈值条件。

先来理解下概念：递归过程一般通过函数或子过程来实现。递归方法：在函数或子过程的内部，直接或者间接地调用自己的算法。充分必要条件是:问题具有某种可借用的类同自身的子问题描述的性质；某一有限步的子问题(也称本原问题)有直接的解存在。注意：递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。可以自己写几个就知道了

判断递归：只用看函数是否调用了其本身。类似这样的形式。有函数int FUN(int a){ .......... FUN(a); ..........}这就是递归

递归函数提供了不一样的思维方式，用他来解决往往程序要短小很多，思维也会很清晰。它很适合解决树中的一些问题，在编译原理中也可以经常看到。它的主要的解决问题的思维是这样的：先解决最基础的简单的问题；然后把复杂的问题归结为较简单的问题或把较大的问题分解为较小的问题。下面这小段程序是用递归写的用来求1到n所有这些正整数的和的：int f(int n){ if(n==1) return 1; return n+f(n-1);}第一句解决了最简单的问题，就是n==1的情况。接下去在求较复杂的f（n）的时候把它归结为较简单的问题f（n-1）。用递归也有几个需要注意的问题：1.程序总得要有机会让它退出来，不然会变成死循环。就象这里的第一句，而且一般来说位置也通常在第一句。2.递归还有性能开销。一是因为函数调用时参数的入栈出栈操作。二是有些问题处理不当会出现重复计算（不是很老到的程序员经常会出这样的问题，导致性能有问题，然后说递归根本没实际意义）。

var ia,ib,ic:longint; f:array[0..21,0..21,0..21]of longint;function w(a,b,c:longint):longint;begin w:=0; if(f[a,b,c]>0)then exit(f[a,b,c]); if(a<=0)or(b<=0)or(c<=0)then begin w:=1; end else if(a>20)or(b>20)or(c>20)then begin w:=w(20,20,20); end else if(a<b)and(b<c)then begin w:=w(a,b,c-1)+w(a,b-1,c-1)-w(a,b-1,c); end else w:=w(a-1,b,c)+w(a-1,b-1,c)+w(a-1,b,c-1)-w(a-1,b-1,c-1); f[a,b,c]:=w;end;begin fillchar(f,sizeof(f),0); read(ia,ib,ic); if(ia>20)then ia:=20; if(ib>20)then ib:=20; if(ic>20)then ic:=20; writeln(w(ia,ib,ic));end.加入了记忆优化的递归,不优化的话20 20 20 的输入会严重超时. -----我加了个范围检测,看看这次行不?

这是递归的一个有趣用法，输出：3 3地址4 4地址4 4地址3 3地址……等等。目的是观察栈空间的变化

//循环实现#include<stdio.h>int main(){    int n, t = 0;    scanf("%d", &n);    if(n<=0)return 0;    else    while(n){        t = t * 10 + n % 10;        n /= 10;    }    printf("%d", t);    return 0;}简单修改一下就可以变递归了。代码如下#include<stdio.h>int fanzhuan(int n,int t){    t = t * 10 + n % 10;    n /= 10;    if(n>0)return fanzhuan(n,t);    return t;}int main(){    int n, t = 0;    scanf("%d", &n);    if(n<=0)return 0;    else t=fanzhuan(n,t);    printf("%d", t);    return 0;}

int facto(int n){if(n==1)return 1;elsereturn n*facto(n-1);}void main(){    int n;    scanf("%d",&n);    printf("%d ", facto(n));    return 0;}

在main函数以外 编写自定义函数int fun(a){ if(a==1||a==2) return 1; else return arr[a-1]+arr[a-2];}

B以数组t和数组元素个数n调用的f()，之后在f()内部，当n非零时，以数组元素与以n减一调用的f()求和，最终实现对n个数组元素（第1个~第n个元素，数组下标为0~n-1）求和。

=rfact(5)*rfact(4)*rfact(3)*rfact(2)*1=rfact(5)*rfact(4)*rfact(3)*2=rfact(5)*rfact(4)*6=rfact(5)*24=120。

如何使用递归函数的返回值 给定一个二叉树，返回所有从根节点到叶子节点的路径。 说明: 叶子节点是指没有子节点的节点。 示例: 给定一个二叉树，它的每个结点都存放着一个整数值。 找出路径和等于给定数值的路径总数。 路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。 二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。 示例：

说的太多反而不清楚是什么回答问题最好不要复制粘贴。。。递归就是一个函数内出现调用本身的现象，举个最简单的例子，求阶乘：当n=0或1时，n！=1；当n>1时，n！=n*(n-1)!通过这样的思想，程序写为：int fun(int n){ if(n<2) return 1; else return n*fun(n-1); }看到了fun函数内调用了它本身fun，可以想象一步步下去就可以得到计算结果。

我做了个图，如果需要将你的EMAIL地址发过来。

你先了解这个函数的作用，结果就是 n*(n/(2^1)*(n/(2^2))*(n/(2^3))*(n/(2^4))……*1n*(n/2)*(n/4)*(n/8)*……*1while( n >= 0){ if(n !=0) { push();//将n压入栈内 n = n/2 } else { push(n+1);//或者是push(1); }}double result = 1;while(栈不为空){result = result * pop();//取出值并相乘}printf("%lf",result);这个是伪代码哈，自己去实现

递归就是一个函数内出现调用本身的现象，举个最简单的例子，求阶乘：当n=0或1时，n！=1；当n>1时，n！=n*(n-1)!通过这样的思想，程序写为：intfun(intn){if(n<2)return1;elsereturnn*fun(n-1);}看到了fun函数内调用了它本身fun，可以想象一步步下去就可以得到计算结果。

可以参考下面的代码：#include<stdio。h>voidprintData（intdata）if（data==0）return；printf（"%d"，data%10）；printData（data/10）；intmain（）intdata；printf（"Enteranumber："）；scanf（"%d"，&data）；return0；介绍在数理逻辑和计算机科学中，递归函数或μ-递归函数是一类从自然数到自然数的函数，它是在某种直觉意义上是"可计算的" 。事实上，在可计算性理论中证明了递归函数精确的是图灵机的可计算函数。递归函数有关于原始递归函数，并且它们的归纳定义(见下)建造在原始递归函数之上。但是，不是所有递归函数都是原始递归函数 — 最著名的这种函数是阿克曼函数。

def factorial(n):if n<0:return "负数不可以阶乘"if n==1 or n==0:return 1return n*factorial(n-1)print(factorial(10))函数体里 调用 函数本身 就行

int fac(int n); { int y; if(n==0||n==1) y=1; else y=n*fac(n-1); return y; }这个才是正确的

你给的题目不完整,如果你要求的是：1+2+3+...+N, A选项就是错的,因为（递归时倒数）第一项的值原本就是1,B选项是对的；如果题目本身不是求1+2+3+...+N,而是：2+3+...+N, A选项就是对的,可视为（递归时倒数）第一项的值是0.

调用过程就是自己调用自己，直到满足退出条件，这个很重要比如要求5的阶乘，先要求4的阶乘，接着求3的阶乘，。。。最后当n=1时，直接return 1也就结束了递归。其实很好理解的。。

intjiecheng(intn){if(n==1)//当n等于1时，直接返回。return1;else//否则，返回n*jiecheng(n-1)returnn*jiecheng(n-1);}例如：n=3，运行过程如下：调用返回主函数6↓↑jiecheng(3)3*jiecheng(2)=3*2*jiecheng(1)=3*2*1↓↑jiecheng(2)2*jiecheng(1)=2*1↓↑jiecheng(1)→1

把错误贴上来看看

额,抽象的说就是解决一个问题时重复使用一个动作,那么就可以用递归的方式来解决,告诉电脑重复做这个动作就行.结合看一些递归算法的简单程序,应该好懂些.

就是选择的 VLOOKUP函数 中的部分项目指向了被 引用的位置，而被引用的位置又涉及到了vlookup函数中的数据。具体问题可以查看帮助中的 “循环引用”，举个简单例子：你输入A1 公式 =B1+C1B1中输入了 50C1中输入了 =A1+20 结果就如出现该提示。

仔细分析下你的程序：一次调用age(n)，实参n=5!=1,所以c在第一次调用时是随机值,age(5)=c=age(4)+2二次调用age(n),实参n=4!=1,age(4)=c=c+2;三次调用age(n),实参n=3!=1,age(3)=c=c+2;四次调用age(n),实参n=2!=1,age(2)=c=c+2;五次调用age(n),实参n=1,age(1)=c=c+2;此时的c实际上已经等于一次调用时的c值+8；而c此时被赋值为10，所以age(5)=18;

数论函数的一种，其定义域与值域都是自然数集，只是由于构作函数方法的不同而有别于其他的函数。处处有定义的函数叫做全函数，未必处处有定义的函数叫做部分函数。最简单又最基本的函数有三个：零函数O（x）=0（其值恒为0）；射影函数；后继函数S（x）=x+1。它们合称初始函数。要想由旧函数作出新函数，必须使用各种算子。代入（又名复合或叠置）是最简单又最重要的造新函数的算子，其一般形状是：由一个m元函数？与m个n元函数 g1,g2,…，gm 造成新函数 ? （g1（x1,x2,…，xn），g2（x1,x2,…，xn），…，gm（x1,x2，…，xn）），亦可记为？（g1，g2,…，gm）（x1，x2,…，xn）。另一个造新函数的算子是原始递归式。具有n个参数u1，u2,…，un的原始递归式为：（图1）具有一个参数的原始递归式可简写为：（图2）其特点是，不能由g、h两函数直接计算新函数的一般值？（u,x），而只能依次计算？（u,0），？（u,1），？（u,2），…；但只要依次计算，必能把任何一个？（u,x）值都算出来。换句话说?只要g,h为全函数且可计算，则新函数f也是全函数且可计算。由初始函数出发，经过有限次的代入于原始递归式而作出的函数叫做原始递归函数。由于初始函数显然是全函数且可计算，故原始递归函数都是全函数且可计算。通常使用的数论函数全是原始递归函数，可见原始递归函数是包括很广的。但是W.阿克曼证明了，可以作出一个可计算的全函数，它不是原始递归的。经过后人改进后，这个函数可写为如下定义的阿克曼函数：（图3）容易看出，这个函数是处处可计算的。任给m,n的值，如果m为0，可由第一式算出；如果m不为0而n为0，可由第二式化归为求g（m,1）的值，这时第一变目减少了；如果m，n均不为0,根据第三式可先计算g（m,n-1），设为α，再计算g（m-1,α），前者第二变目减少（第一变目不变），后者第一变目减少。极易用归纳法证得，这样一步一步地化归，最后必然化归到第一变目为0，从而可用第一式计算。所以这个函数是处处可计算的。此外又容易证明，对任何一个一元原始递归函数？（x），永远可找出一数α使得？（x）<g（α，x）。这样，g（x,x）+1便不是原始递归函数，否则将可找出一数b使得g（x,x）+1<g（b,x）。令x=b，即得g（b,b）+1<g（b,b），而这是不可能的。另一个重要的造新函数的算子是造逆函数的算子，例如，由加法而造减法，由乘法造除法等。一般，设已有函数？（u,x），就x解方程？（u,x）=t,可得x=g（u,t）。这时函数g叫做？的逆函数。至于解一般方程？（u，t,x）=0而得x=g（u，t）可以看作求逆函数的推广。解方程可以看作使用求根算子。？（u,t，x）=0的最小x根（如果有根的话），记为μx【？（u,t,x）=0】。当方程没有根时，则认为μx【？（u,t,x）=0】没有定义。可见，即使？（u,t,x）处处有定义且可计算，但使用求根算子后所得的函数μx【？（u,t,x）=0】仍不是全函数，可为部分函数。但只要它有定义，那就必然可以计算。这算子称为μ算子。如果？（u,t,x）本身便是部分函数，则 μx【？（u,t,x）=0】的意义是：当？（u,t,n）可计算且其值为0,而x<n时？（u,t,x）均可计算而其值非0，则 μx【？（u,t,x）=0】指n；其他情况则作为无定义。例如，如果？（u,t,x）=0根本没有根，或者虽然知道有一根为n，但？（u,t,n-1）不可计算，那么 μx【？（u,t,x）=0】都作为没有定义。在这样定义后，只要 μx【？（u,t,x）=0】有值便必可计算。由初始函数出发，经过有穷次使用代入、原始递归式与 μ算子而作成的函数叫做部分递归函数，处处有定义的部分递归函数称为全递归函数，或一般递归函数。原始递归函数类里还有一个重要的子类称为初等函数类，它是由非负整数与变元经过有穷次加、算术减（即|α-b|）、乘、算术除（图2）、叠加Σ、叠乘П而得的函数组成的类。波兰人A.格热高契克把原始递归函数类按定义的复杂程度来分类，称为格热高契克分层或波兰分层。要把递归函数应用于谓词，首先要定义谓词的特征函数（图6）。谓词R（x,y）的特征函数是（图4）：称谓词R 是递归谓词，若R 的特征函数是递归函数；称自然数子集A为递归集，若谓词x∈A是递归谓词。有了上述定义，就可以用递归函数来处理递归谓词和递归集。为了处理N×N（其中N 为自然数集）的子集，就要建立配对函数，所谓配对函数通常是指由N×N 到N 的一个函数？（x，y）与它的逆函数g1（z），g2（z）。它们都满足以下关系：（图5）可以构造许多原始递归的配对函数。递归函数也可以用来处理符号串。处理的办法是对符号及符号串配以自然数。这方法是K.哥德尔开始引进的，因此称为哥德尔配数法。例如，在要处理的符号系统{α1，α2，α3,…}中，可以用奇数1，3，5，7，…作为α1,α2，α3，α4，…的配数，符号串（图7）以（图8）为其配数，其中Ps是第s个素数，nij是αij的配数。这种配数称为哥德尔配数。有了哥德尔配数法，就可以用递归函数来描写、处理有关符号串的谓词了。 如何快速正确的写出递归函数？写一个递归函数是非常程式化的东西，只要按照一定的规则来写，就可以很容易地写出递归函数。写递归函数有三步：①写出迭代公式；②确定递归终止条件；③将①②翻译成代码。下面举一个例子，希望能帮助大家体会这一原则写一个函数，求：f（n）=1+2+3+……+n的值①写出迭代公式：迭代公式为②确定递归终止条件：f（1）=1就是递归终止条件③将①②翻译成代码：将迭代公式等号右边的式子写入return语句中，即return （Sum（n-1））+n;将1！=1翻译成判断语句：if（n==1） return 1;按照先测试，后递归的原则写出代码。 longSum(intn){if(n==1)return1;return(Sum(n-1))+n;} 【pascal语言】 //使用VB代码格式，实际为Pascalfunctiondo(x:integer);beginifx<=1thenexit(0)elseifx>1thenexit(do(x-1)+10)end;

递归：函数下一次的参数是函数自身上一次的输出值。（也就是说，函数的下一次取决于上一次的结果，自身依赖）。也正是因为如此，这样的函数必须有终止值（即递归必须有一个条件限定）。否则就会进入死循环。“递归”分成“直接递归”、“简介递归”。具体可以参考我的博客（点击， http://www.cnblogs.com/serviceboy/archive/2009/07/19/1526590.html，查看，有代码有具体示例解释）。 给出一个求n！的C递归：int Fun(int n){ if (n==0 || n==1) return 1; return Fun(n-1)*n;}

#include <stdio.h>int sum(int n) { if(n==1) return 1; return sum(n-1)+n*n*n; } int main() { printf("%d ",sum(7)); return 0;}

其实思路很简单，编程语言中的递归对应数学中的递推式。这里的递推式是一个比较抽象的概念举个简单例子：求解阶乘，其递推式是，f(n)=n*f(n-1)再举个抽象例子：汉诺塔问题，若要解决n个汉诺塔的问题，需要先解决n-1个汉诺塔的问题，那么这就可以构造出一个递推式，其实也有点动态规划、分治的意思。一言以蔽之：可以用数学语言表达成递推式的均可以用递归函数解决。

从主函数fun(6,&x)开始调用。调用的时候，实参6和&x将自身的值传递给形参n,s,接着，开始执行fun函数体内的语句第一次调用：判断if(n==0||n==1)，此时的n值为6，不满足条件，执行else部分语句。 fun(n-1,&f1);fun(n-2,&f2);先调用fun(n-1,&f1);而fun(n-2,&f2);需要当fun(n-1,&f1);符合if条件以后才轮到它执行第二次调用：此时，形参n=6转变为实参n,fun（n-1,&f1）等价于fun(5,&f1),继续判断，if(n==0||n==1)，又不满足条件，于是，重复之前的操作，转向else部分执行。 fun(n-1,&f1);fun(n-2,&f2);此时的n=5,同样是先调用fun(n-1,&f1);后面那个fun(n-2,&f2);同样处于等待状态，等待前面的 fun(n-1,&f1);符合IF条件后才轮到它执行，于是，fun(n-1,&f1);就这样一层一层执行下去，每执行一次，n的值减一,当n=1的时候，执行if部分，这时，便可以在fun(n-1,&f1);执行完毕只有继续执行fun(n-2,&f2);，接着，返回前一次调用的状态，开始执行fun(n-2,&f2);比如当n=2的时候，执行完fun(2-1=1,&f1)以后，便开始执行fun(2-2=0,&f2);和它后面的语句，最终，函数返回上一次调用的状态，即fun(3,&f1);此时，fun(3,&f1)已经执行完毕，因为之前我们已经把fun(2,&f1)执行完了，接着，应该执行的是fun(3-2=1,&f2);当这个函数最后终也符合if部分要求，又返回到前面的fun(4,&f1),执行完后，开始执行fun(4,&f2)，这样一个流程。通常来说，递归可以简化代码，但同时也会增加系统开销并且让程序阅读的时候要比正常的顺序程序难以理解一些。不过，现代的硬件飞速发展，用递归是完全可以的。

一个函数在自己内部调用自己这就是递归。function A() {A();}

好的我帮你你分析以下你的程序：1 调用是age(5) 它再调用age(4),然后返回age(4)+22 age(4)过程中调用age(3),然后返回age(3)+23 在age(3)过程中调用age(2),然后返回age(2)+24 在age(2)过程中调用age(1),然后返回age(1)+25 在age(1)过程中，直接返回10的值。由上过程可以看出递归深度是5，那么：age(5)=age(4)+2 age(4)=age(3)+2 age(3)=age(2)+2 age(2)=age(1)+2 age(1)=10所以 age(5)=18这仅仅是一个单向递归，深度是单向延伸的。还有向广度延伸的

递归具体用法其实就是让你把一个问题分解成很多个类似的情况，虽然你要解决这个问题非常难，莫名其妙，要你想几年，但是把他一直递归分解，就变成很好理解的单种情况，而你整个问题又是跟这个单种情况类似，把整个问题通过递归调用一层一层分解到最低级简单的那种情况，就是你所需要理解的了。一个函数在它的函数体内调用它自身称为递归调用。这种函数称为递归函数。C语言允许函数的递归调用。在递归调用中，主调函数又是被调函数。执行递归函数将反复调用其自身，每调用一次就进入新的一层。（引自谭浩强的C语言书里）用递归法计算n!可用下述公式表示： n!=1 (n=0,1) n×(n-1)! (n>1)具体如下long ff(int n){ long f; if(n<0) printf("n<0,input error"); else if(n==0||n==1) f=1; else f=ff(n-1)*n; return(f);}main(){ int n; long y; printf(" input a inteager number: "); scanf("%d",&n); y=ff(n); printf("%d!=%ld",n,y);}较难题：一块板上有三根针，A，B，C。A针上套有64个大小不等的圆盘，大的在下，小的在上。如图5.4所示。要把这64个圆盘从A针移动C针上，每次只能移动一个圆盘，移动可以借助B针进行。但在任何时候，任何针上的圆盘都必须保持大盘在下，小盘在上。求移动的步骤。具体如下move(int n,int x,int y,int z){ if(n==1) printf("%c-->%c ",x,z); else { move(n-1,x,z,y); printf("%c-->%c ",x,z); move(n-1,y,x,z); }}main(){ int h; printf(" input number: "); scanf("%d",&h); printf("the step to moving %2d diskes: ",h); move(h,"a","b","c");} 从程序中可以看出,move函数是一个递归函数，它有四个形参n,x,y,z。n表示圆盘数，x,y,z分别表示三根针。move 函数的功能是把x上的n个圆盘移动到z上。当n==1时，直接把x上的圆盘移至z上，输出x→z。如n!=1则分为三步：递归调用move函数，把n-1个圆盘从x移到y；输出x→z；递归调用move函数，把n-1个圆盘从y移到z。在递归调用过程中n=n-1，故n的值逐次递减，最后n=1时，终止递归，逐层返回。当n=4 时程序运行的结果为：

递归函数有三点要求：1，递归的终止点，即递归函数的出口2，不断的递归调用自身3，递归函数主体内容，即递归函数需要做的事情ps：3一般可以放在2的前面或者后面，一般1放最前面。另外，2和3可以根据不同的需要合并，比如，有时候递归函数的主体就是返回调用下层函数所得到的结果。具体例子如下：void fun(int n){ if(n<=0) return; //1 这是递归的终点，即出口 fun(n-1); //2、递归函数自身的调用 cout<评论00加载更多

我觉得只针对这个问题你可以这样理解试试：void p(int i){ cout<<i<<" "<<endl;}for(int i=k;i>0;i--){ p(i);}

//---------------------------------------------------------------------------#include <stdio.h>void int_to_str(int n){ if (n) { if (n<0) { n*=-1; putchar("-"); } int_to_str(n/10); putchar("0"+n%10); }}int main(void){ int a=-512,b=1024; int_to_str(a); /*测试负数*/ putchar(" "); int_to_str(b); /*测试正数*/ return 0;}//---------------------------------------------------------------------------

#include<stdio.h>int sum(int n){return n?n+sum(n-1):0;}int main(){ int n;  scanf("%d",&n);  printf("1+2+...+%d=%d ",n,sum(n));  return 0;}

4+3+2 = 9

以下是Python代码实现：def f(n, x):if n == 1:return xelse:return x * f(n-1, x)n1 = 3x = 2if n1 == 1:y = xelse:y = f(n1, x)print(y)当n1为1时，y=x；否则通过递归函数f计算y=xx^(n-1)的值。在上面的代码中，n1=3，x=2，因此y=2^2^1=4。

function abc(num1){ if(num1>3){ abc(--num1); } document.writeln(num1);}看看推荐答案...document.writeln(num1);不在else里面document.writeln(num1);这句是一定会执行的

int age(int n){ int c; if(n==1)c=10; else c=age(n-1)+2; return(c);}#include<stdio.h>void main(){ printf("%d",age(5));}

递归函数的基本思想如下：递归就是方法自己调用自己 递归特点: 有临界点 当一个方法执行完毕,或者遇到retrun,就会返回,函数就是出栈。 待求解问题的解 输入变量x的函数f(x)，通过寻找函数g( ), 使得f(x) = g(f(x-1))。且已知f(0)的值, 就可以通过f(0)和g( )求出f(x)的值。扩展到多个输入变量x, y, z等, x-1也可以推广到 x - x1 , 只要递归朝着 “出口” 的方向即可。把一个问题划分成一组子问题, 依次对这些子问题求解。子问题之间是横向的, 同类的关系 递归: 把一个问题逐级分解成子问题。子问题与原问题之间是纵向的, 同类的关系。语法形式上: 在一个函数的运行过程中, 调用这个函数自己。直接调用: 在fun()中直接执行fun()。间接调用: 在fun1()中执行fun2(); 在fun2()中又执行fun1() 递归与枚举的区别。递归的三个要点：递归式：如何将原问题划分成子问题。 递归出口: 递归终止的条件, 即最小子问题的求解,可以允许多个出口 。界函数: 问题规模变化的函数, 它保证递归的规模向出口条件靠拢，求阶乘的递归程序。

楼上两位何必说得那么复杂!!递归函数就是,一个函数自己调用自己本身(只是在调用时参数上有所不同).

递归式解决逻辑问题的。基本思想是：：把规模大的、较难解决的问题变成规模较小的、易解决的同一问题。规模较小的问题又变成规模更小的问题，并且小到一定程度可以直接得出它的解，从而得到原来问题的解。c有一个汉诺塔,就是非用递归才能解决的一个问题。利用递归算法解题，首先要对问题的以下三个方面进行分析：一、决定问题规模的参数。需要用递归算法解决的问题，其规模通常都是比较大的，在问题中决定规模大小（或问题复杂程度）的量有哪些？把它们找出来。二、问题的边界条件及边界值。在什么情况下可以直接得出问题的解？这就是问题的边界条件及边界值。三、解决问题的通式。把规模大的、较难解决的问题变成规模较小、易解决的同一问题，需要通过哪些步骤或等式来实现？这是解决递归问题的难点。

递归函数的本质就是以一个更换了一定条件的状态（不同的参数、或是不同的全局变量）再一次调用这个函数（目的是向可以获得答案的目标靠近一步）。

在数理逻辑和计算机科学中，递归函数或μ-递归函数是一类从自然数到自然数的函数，它是在某种直觉意义上是可计算的 。事实上，在可计算性理论中证明了递归函数精确的是图灵机的可计算函数。递归函数有关于原始递归函数，并且它们的归纳定义(见下)建造在原始递归函数之上。但是，不是所有递归函数都是原始递归函数 — 最著名的这种函数是阿克曼函数。其他等价的函数类是λ-递归函数和马尔可夫算法可计算的函数。 一个含直接或间接调用本函数语句的函数被称之为递归函数，在上面的例子中能够看出，它必须满足以下两个条件：1） 在每一次调用自己时，必须是（在某种意义上）更接近于解；2） 必须有一个终止处理或计算的准则。例如：梵塔的递归函数 //Cvoid hanoi(int n,char x,char y,char z){if(n==1)move(x,1,z);else{hanoi(n-1,x,z,y);move(x,n,z);hanoi(n-1,y,x,z);}}阶乘的递归函数，公式如下： //C++int Factorial(int n){if(n==0||n==1)return 1;elsereturn n * Factorial(n-1)}

n % 10n / 10

程序设计中我们不可逃避的重要概念就是递归函数，就个人而言递归是一个比较难以理解的概念。如果要是做一个比喻的话，递归就是一种结果导向的思维，用最终的结果来反向推导需要的东西。可能这样说还是一个非常抽象的概念。总之不管怎么解释都是一个相对来说抽象的概念，那我们就直接看一下，UE4里边是如何定一个递归函数。 还是使用蓝图定义一个最为简单的递归函数，这个函数其实就是一个生成树算法。虽然没有数的逻辑结构，但是它的数字就已经表达了一个树。 这一系列的数字已经表达了一个树。下面是蓝图函数的定义。 值得注意的一点是UE4蓝图貌似无法定义局部变量。变量的定义都要在函数参数，与类的成员变量里面。运行后打印效果。 而为什么这串数字是反向的，可能因为递归本来就是逆向思维。当然可以调整成正的，这里只是稍微演示一下，UE4的函数定义语法，和递归的表达。不做过多解释。

数学上的定义：对于某一函数f(x)，其定义域是集合A，那么若对于A集合中的某一个值X0，其函数值f(x0)由f(f(x0))决定，那么就称f(x)为递归函数。 编程语言中的定义：在编程语言中，把直接或间接地调用自身的函数称为递归函数。函数的构建通常需要一个函数或者一个过程来完成。 其实说白里就是一句话：自身调用自身的函数。

在数学上，关于递归函数的定义如下：对于某一函数f(x)，其定义域是集合A，那么若对于A集合中的某一个值X0，其函数值f(x0)由f(f(x0))决定，那么就称f(x)为递归函数。在编程语言中，把直接或间接地调用自身的函数称为递归函数。函数的构建通常需要一个函数或者一个过程来完成。递归函数是建立在嵌套的基础上的，只不过嵌套调用了自己本身，而且经常不是显式调用。一个含直接或间接调用本函数语句的函数被称之为递归函数，它必须满足以下两个条件：1）在每一次调用自己时，必须是（在某种意义上）更接近于解；2）必须有一个终止处理或计算的准则。/////////////////////////如一个非法的递归（嵌套）调用：voidff(){ff();}intmain(){ff();system("pause");return0;}//////////////////////////////斐波那契数列的递归解法/////////////////////////写法虽然简单，但是效率不高。#include<iostream.h>//FibonaccisequenceintGetFibnRes(intn){if(n>1){returnGetFibnRes(n-1)+GetFibnRes(n-2);}if(n<0){cout<<"uneffectiveparameter!"<<endl;return-1;}returnn;}intmain(){intn;intres;while(1){cout<<"PleaseinputFibonacciSequence"snumber"<<endl;cin>>n;res=GetFibnRes(n);cout<<res<<endl;system("pause");}return0;}

递归函数是数论函数的一种，其定义域与值域都是自然数集，只是由于构作函数方法的不同而有别于其他的函数。 最简单又最基本的函数有三个：零函数，射影函数，后继函数，它们合称初始函数。 要想由旧函数作出新函数，必须使用各种算子。在数理逻辑和计算机科学中，递归函数是一类从自然数到自然数的函数，它是在某种直觉意义上是"可计算的"。事实上，在可计算性理论中证明了递归函数精确的是图灵机的可计算函数。

递归在数学与计算机科学中，是指在函数的定义中使用函数自身的方法。递归一词还较常用于描述以自相似方法重复事物的过程。例如，当两面镜子相互之间近似平行时，镜中嵌套的图像是以无限递归的形式出现的。一般用在可以被简化成各个小问题的复杂大问题里。斐波那契数列是典型的递归案例：Fib(0) = 0 [基本情况]Fib(1) = 1 [基本情况]对所有n > 1的整数：Fib(n) = (Fib(n-1) + Fib(n-2)) [递归定义]

#include <stdio.h>long f(int n){return n == 0 ? 1: n*f(n-1);}int main(void){printf("%ld ", f(4) + f(6) + 7);return 0;}扩展资料：编程语言中，函数Func(Type a,……)直接或间接调用函数本身，则该函数称为递归函数。递归函数不能定义为内联函数。在数学上，关于递归函数的定义如下：对于某一函数f(x)，其定义域是集合A，那么若对于A集合中的某一个值X0，其函数值f(x0)由f(f(x0))决定，那么就称f(x)为递归函数。参考资料来源：百度百科-递归函数

double sum(int n){ if(n==1) { return 1; } else { return n+sum(n-1); }}

反抗精神的恢复健康十分时间后付款了时间上开发设计开发刻录机

递归函数的就是从一个作业的，然后归到一个男生，然后实现递归需要一些特殊条件。