SQL 函数递归

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)}

一个函数在自己内部调用自己这就是递归。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;}//---------------------------------------------------------------------------

所谓递归，说的简单点，就是函数自己调用自己，然后在某个特定条件下。结束这种自我调用。如果不给予这个结束条件，就成了无限死循环了。这样这个递归也就毫无意义了。如下面问题1 1 2 3 5 8 13 21 ........n分析可以看出， i 表示第几个数， n 表示该数的值当i = 1 时， n = 1;当i = 2 时， n = 1;当i = 3 时 n = i1 + i2；当i = 4 时 n = i2 + i3所以可以写个函数int fun(int n) // 这里的n代表第几个数{ if(1 == n || 2 == n) // 第一个数 { return 1; } else { return fun(n - 1) + fun(n - 2); // 这里就是自己调用自己，形成循环自我调用。 }}注： 以上代码只是用来演示递归，不包含错误校验。 在实际生产过程中。该代码不够健壮。如此，就完成了递归。你就可以求得第n个数了。何时考虑使用递归。当你分析一个问题的时候，发现这个问题，是一个自我循环时，而且这个自我循环到一个给定值，就可以终止的时候，你就快要考虑递归了。

#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

#include#defineCOL10//一行输出10个longscan(){//输入求fibonacci函数的第N项intn;printf("InputtheN=");scanf("%d",&n);returnn;}longfibonacci(intn){//fibonacci函数的递归函数if(0==n||1==n){//fibonacci函数递归的出口return1;}else{returnfibonacci(n-1)+fibonacci(n-2);//反复递归自身函数直到碰到出口处再返回就能计算出第n项的值}}intmain(void){inti,n;n=scan();printf("Fibonacci数列的前%d项 ",n);for(i=0;i{printf("%-10ld",fibonacci(i++));//调用递归函数并且打印出返回值if(i%COL==0){//若对COL取余等于0就换行，也就是控制每行输出多少个，//而COL=10就是每行输出10个printf(" ");}}printf(" ");return0;}

这题主要考察递归函数的思想。代码如下：#include<stdio.h>int  fbi(int i);//递归函数：输出数列的第i项数据，这里i从0开始计算。int main(){int i,N;scanf("%d",&N);for(i=0;i<N;i++)printf("%d ",fbi(i));return 0;}int fbi(int i)//递归函数：输出数列的第i项数据。这里i从0开始计算。 {if(i<2){return i;}else{return fbi(i-1)+fbi(i-2);}}扩展资料一个函数可以调用其他函数。如果这个函数在内部调用它自己，那么这个函数就叫递归函数。递归函数的作用和循环的方法效果一样，即递归函数本质上是一个方法的循环调用，注意：有可能会出现死循环。因此，使用递归函数时，一定要定义递归的边界（即什么时候退出循环）。注意：在实际使用中，递归函数由于消耗时间比较长（相比for循环和while循环），所以很少使用。要使递归函数有用，则递归函数必须有一个方法来控制递归调用的次数。每次函数调用自己时，循环都会重复。现在应该能发现该函数的问题，因为它没有办法停止递归调用。这个函数就像一个无限循环，因为没有代码阻止它重复。参考资料来源：百度百科——递归函数

以下是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。

递归调用是一种特殊的嵌套调用，是某个函数调用自己或者是调用其他函数后再次调用自己的，只要函数之间互相调用能产生循环的则一定是递归调用，递归调用一种解决方案，一种是逻辑思想，将一个大工作分为逐渐减小的小工作。递归函数特点：1、函数要直接或间接调用自身。2、要有递归终止条件检查，即递归终止的条件被满足后，则不再调用自身函数。3、如果不满足递归终止的条件，则调用涉及递归调用的表达式。在调用函数自身时，有关终止条件的参数要发生变化，而且需向递归终止的方向变化。扩展资料：递归调用的过程：递归调用之前的语句是从上到下的，函数调用之后的语句呢是从下到上的，因为后面的语句要等最下层或者最里面最后调用的那个函数执行之后不再调用了开始执行，然后返回上一层的时候再执行上一层函数调用后面的语句。并且特别注意的是，每次函数返回后直接就是函数调用后面的语句。递归其实就是利用了函数调用的一些特点，很巧妙的不断调用自己，把一个很大的问题分成了很多部分，让每一个函数解决一部分，并且上一层的结果编译器给我们保留了起来，返回的时候还能用。所以递归调用一定要是每深入一层都会把问题变得越来越小，而且最后能解决，不然就会无限制的调用自己，形成一个无限的循环，最后造成栈的溢出，最后程序崩溃。参考资料来源：百度百科-递归调用

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

把错误贴上来看看

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){v=1;printf("%d->%d ",f,t);}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++){ a[k+1]=i;v+=q(k+1,a);}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个数的组合）要求的序列。

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

就是选择的 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个汉诺塔的问题，那么这就可以构造出一个递推式，其实也有点动态规划、分治的意思。一言以蔽之：可以用数学语言表达成递推式的均可以用递归函数解决。

递归算法（英语：recursion algorithm）在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。递归式方法可以被用于解决很多的计算机科学问题，因此它是计算机科学中十分重要的一个概念。绝大多数编程语言支持函数的自调用，在这些语言中函数可以通过调用自身来进行递归。计算理论可以证明递归的作用可以完全取代循环，因此在很多函数编程语言（如Scheme）中习惯用递归来实现循环。

从主函数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)，这样一个流程。通常来说，递归可以简化代码，但同时也会增加系统开销并且让程序阅读的时候要比正常的顺序程序难以理解一些。不过，现代的硬件飞速发展，用递归是完全可以的。

你的递归程序是错的，我转来个对的，带讲解的，你看看。语言函数的递归和调用一、基本内容：C语言中的函数可以递归调用，即：可以直接（简单递归）或间接（间接递归）地自己调自己。要点：1、C语言函数可以递归调用。2、可以通过直接或间接两种方式调用。目前只讨论直接递归调用。二、递归条件采用递归方法来解决问题，必须符合以下三个条件：1、可以把要解决的问题转化为一个新问题，而这个新的问题的解决方法仍与原来的解决方法相同，只是所处理的对象有规律地递增或递减。说明：解决问题的方法相同，调用函数的参数每次不同（有规律的递增或递减），如果没有规律也就不能适用递归调用。2、可以应用这个转化过程使问题得到解决。说明：使用其他的办法比较麻烦或很难解决，而使用递归的方法可以很好地解决问题。3、必定要有一个明确的结束递归的条件。说明：一定要能够在适当的地方结束递归调用。不然可能导致系统崩溃。三、递归实例例：使用递归的方法求n!当n>1时，求n!的问题可以转化为n*(n-1)!的新问题。比如n=5：第一部分：5*4*3*2*1n*(n-1)!第二部分：4*3*2*1(n-1)*(n-2)!第三部分：3*2*1(n-2)(n-3)!第四部分：2*1(n-3)(n-4)!第五部分：1（n-5）!5-5=0，得到值1，结束递归。源程序：fac(intn){intt;if(n==1)||(n==0)return1;else{t=n*fac(n-1);returnt;}}main(){intm,y;printf(“Enterm:”);scanf(“%d”,&m);if(m<0)printf(“InputdataError! ”);else{y=fac(m);printf(“ %d!=%d ”,m,y);}}四、递归说明1、当函数自己调用自己时，系统将自动把函数中当前的变量和形参暂时保留起来，在新一轮的调用过程中，系统为新调用的函数所用到的变量和形参开辟另外的存储单元（内存空间）。每次调用函数所使用的变量在不同的内存空间。2、递归调用的层次越多，同名变量的占用的存储单元也就越多。一定要记住，每次函数的调用，系统都会为该函数的变量开辟新的内存空间。3、当本次调用的函数运行结束时，系统将释放本次调用时所占用的内存空间。程序的流程返回到上一层的调用点，同时取得当初进入该层时，函数中的变量和形参所占用的内存空间的数据。4、所有递归问题都可以用非递归的方法来解决，但对于一些比较复杂的递归问题用非递归的方法往往使程序变得十分复杂难以读懂，而函数的递归调用在解决这类问题时能使程序简洁明了有较好的可读性；但由于递归调用过程中，系统要为每一层调用中的变量开辟内存空间、要记住每一层调用后的返回点、要增加许多额外的开销，因此函数的递归调用通常会降低程序的运行效率。五、程序流程fac(intn)/*每次调用使用不同的参数*/{intt;/*每次调用都会为变量t开辟不同的内存空间*/if(n==1)||(n==0)/*当满足这些条件返回1*/return1;else{t=n*fac(n-1);/*每次程序运行到此处就会用n-1作为参数再调用一次本函数,此处是调用点*/returnt;/*只有在上一句调用的所有过程全部结束时才运行到此处。*/}}

说的太多反而不清楚是什么回答问题最好不要复制粘贴。。。递归就是一个函数内出现调用本身的现象，举个最简单的例子，求阶乘：当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；介绍在数理逻辑和计算机科学中，递归函数或μ-递归函数是一类从自然数到自然数的函数，它是在某种直觉意义上是"可计算的" 。事实上，在可计算性理论中证明了递归函数精确的是图灵机的可计算函数。递归函数有关于原始递归函数，并且它们的归纳定义(见下)建造在原始递归函数之上。但是，不是所有递归函数都是原始递归函数 — 最著名的这种函数是阿克曼函数。

递归具体用法其实就是让你把一个问题分解成很多个类似的情况，虽然你要解决这个问题非常难，莫名其妙，要你想几年，但是把他一直递归分解，就变成很好理解的单种情况，而你整个问题又是跟这个单种情况类似，把整个问题通过递归调用一层一层分解到最低级简单的那种情况，就是你所需要理解的了。一个函数在它的函数体内调用它自身称为递归调用。这种函数称为递归函数。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 时程序运行的结果为：

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; }这个才是正确的

代码如下：#include <stdio.h>int acculate(int n){ if(n==1) return 1; else if(n==2) return 2; else if(n==3) return 4; else return 2*acculate(n-1)-acculate(n-3);}void main(){ int n,sum; n=30; sum=acculate(n); printf("%d ",sum);}

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

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

《算法导论》一书花了很大的篇幅去讨论递归算法时间复杂度的分析，在《算法导论》里叫做不变式的主定理。这个比较难，不是一两天能学会的，多投入时间和精力去啃吧。

函数嵌套是语言特性，递归调用是逻辑思想。 1 函数嵌套 函数嵌套允许在一个函数中调用另外一个函数，比如有三个函数 例: funca() { funcb(); } funcb() { funcc(); } funcc() { cout << "Hello" <<endl; } 这个就叫做嵌套调用，它是一个语言提供的程序设计的方法，也就是语言的特性。 2 递归调用 而递归是一种解决方案，一种思想，将一个大工作分为逐渐减小的小工作，比如说一个和尚要搬50块石头，他想，只要先搬走49块，那剩下的一块就能搬完了，然后考虑那49块，只要先搬走48块，那剩下的一块就能搬完了……，递归是一种思想，只不过在程序中，就是依靠函数嵌套这个特性来实现了。 递归最明显的特点就是，自己调用自己。 例: funca() { if(statement1) funca(); else exit(0); } 概括说，函数嵌套就是函数调用函数，是普遍的，递归就是函数调用自身，使函数嵌套的一个特例。 嵌套调用就是某个函数调用另外一个函数，递归调用是一个函数直接或间接的调用自己。举几个例子：A调用B（嵌套）B调用C（嵌套）A调用A（递归）A调用B B调用A （递归）A调用B B调用C C调用A （递归）

递归函数的优点是定义简单，逻辑清晰。理论上所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。使用递归函数时，需要防止栈溢出。

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

这是递归的一个有趣用法，输出：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;}