递归函数c语言例题解析,C语言函数递归问题

递归函数c语言例题解析,C语言函数递归问题详细介绍

本文目录一览： c语言 函数的递归调用问题 这个地方没怎么学明白 求给个详细的过程 谢谢了

fun(7)=7-func(5)
func(5)=5-fun(3)
fun(3)=3-fun(1)=3-3
可知fun(7),依次调用了fun(5),fun(3),fun(1)
然后又依次逆向输出了
3
0
5
2
然后main函数中最后有输出了一次fun(7)的返回值2

C语言题 求解答过程

fun()函数是个递归函数。
递归函数的特点就是自己调用自己，而每个递归函数都必须要有个出点，不然就变死循环了。
fun()函数的出点就是if(x/2>1)中if条件不成立的时候。
程序运行过程分析：
1、第一次调用fun()时，x=7，if(x/2>1)，if条件成立，因此进入fun(x/2)，递归调用自己；
2、第二次调用fun()时，x=x/2, x的值为3，if(x/2>1)，if条件不成立，则输出3，然后回到第一次调用；
3、回到第一次调用，输出7，调用结束。
因此答案应该是3 7

C语言函数递归问题

我一步步的给你讲，就会懂啦：
首先hanoi函数如果把当中的move函数给去掉，就变成了：
void
hanoi(int
n,
char
one
,
char
two,
charthree){
if(n
==
1)
printf("%c->%c\n",
one,
three);
else
{
hanoi(n
-
1,
one,
three,
two);
printf("%c->%c\n",
one,
three);
hanoi(n
-
1,
two,
one,
three);
}}也就是把move(one,three)，变成了printf("%c->%c\n",
one,
three);。少了一个函数，更加清晰
所以这里的hanoi函数就有了执行的内容：printf
下面以3个盘子为例进行模拟计算机的执行过程：
1、hanoi(3,A,B,C)，开始了这步，进入第一层函数，计算机在函数中会进行自我的再次调用（第7行代码）
2、（第7行）：hanoi(2,A,C,B)，于是这又是一个新的hanoi函数，这里我把它成为第二层函数
同样执行到第7行，卡住了，再次一次自我的调用
3、（进入第三层函数）：hanoi(1,A,B,C)，这里的第三层n=1，所以在第四行就显示出了"A->C"，至此，第三层函数结束，回到调用他的第二层函数
4、在第二层当中，继续第8行的内容，所以显示出"A->B"，继续运行，到第9行，开始了有一次自我调用
5、把她称为贰号第三层函数吧。。。hanoi(1,B,A,C)，和第3步类似，这一层函数显示出了"B->C"，然后结束函数，返回调用它的第二层函数
6、第二层函数执行完毕，返回调用它的第一层函数
7、第一层函数中执行到第8行，显示出"A->C",然后执行第9行：hanoi(2,B,A,C)
............
如果看到了这里理清楚了关系就会懂啦，接下来还有一半，如果都写下来就太复杂了-。-
你所说的空函数是指没有返回值，但是这里利用的是电脑调用函数的那种关系来解决的问题，比如上面的3步，会自动返回到第二层函数并继续
还可以这样理解汉诺塔，汉诺塔其实是将复杂的问题简单化，
先不管他有多少个盘子从A到C，我只把它视作3步
就像上面那样找个例子，反复的按照代码模拟计算机运行，过个五次六次，就会懂啦

C语言关于递归的一个题：下面是代码

i=5,程序运行时调用palin函数，函数内部判断传入参数是否小于等于1，不小于1，函数自己调用自己，参数减1，如此循环，直到参数小于等于1时退出。这就是递归的方法。

给我解释一下C语言递归函数？

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

讲一下c语言中递归函数的使用方法

相当于循环，要有判断条件，传递进去的参数要变化，满足条件调用自身，不满足条件就开始一层一层返回。简单例子：
int f(int i){
int sum=0;
if(i>0) sum+=f(i-1);
return sum;
}
main(){
int a=10;
printf("%d",f(a));
}
递归函数有三点要求：
1，递归的终止点，即递归函数的出口
2，不断的递归调用自身
3，递归函数主体内容，即递归函数需要做的事情
ps：3一般可以放在2的前面或者后面，一般1放最前面。另外，2和3可以根据不同的需要合并，比如，有时候递归函数的主体就是返回调用下层函数所得到的结果。
具体例子如下：
void fun(int n){ if(n<=0) return; //1 这是递归的终点，即出口 fun(n-1); //2、递归函数自身的调用 cout<
<n<<endl; 3 递归函数的主体内容}
2,3合并的情况

int fun(int n){ if(n<=0) return 0; return fun(n-1)+fun(n-2); //2 3合并}
</n<

对于C语言的递归还是懵懵懂懂，能帮我分析一下这段代码的执行流程吗，尽量详细一点？

fun5 函数，你一步一步看，
如果 n为1或者2时会返回 2
如果 n为其他时会返回 n + fun5(n-1)
那么我们可以写
fun5(1) = 2
fun5(2) = 2
fun5(3) = 3 + fun5(2) = 3 + 2 = 5
fun5(4) = 4 + fun5(3) = 4 + 3 + fun5(2) = 4 + 3 + 2 = 9
.....
你可以看到，每个等号调用fun5(n-1)函数
对于大的n会一步一步递归调用到小的n，直到n为2给出最后结果。
这就是递归。
你这个应该有个退出的机制，如果没有，那，一直加下去了，可以递归一次后。判断s的值是否符合某个条件，比如大于几小于几，然后再返回？
递归路线图:
f(4)= 4 + f(3)
f(3) = 3 + f(2)
f(2) = 2
反向带入
f(3) = 3+f(2)=3+2=5
f(4)=4+f(3)=4+5=9
结束
这段代码的执行过程
主函数main调用fun5(4)
进入fun5(4) n==4,s=4+fun5(3)
进入fun5(3) n==3,s=3+fun5(2)
进入fun5(2) n==2,s==2,打印2,2--------s
返回 fun5(3) n==3,s=3+fun5(2)=3+2=5,打印3,5--------s
返回 fun5(4) n==4,s=4+fun5(3)=4+5=9,打印4,9--------s
返回main函数,打印9
完整的C语言程序如下
#include

long fun5(int n){

long s;

if((n==1)||(n==2))

s=2;

else

s=n+fun5(n-1);

printf("%d\n",n);

printf("%d--------s\n",s);

return(s);

}

main(){

long x;

x=fun5(4);

printf("%ld",x);

}

c语言中，什么是函数的递归，能举个例子么

(PS:因为很多IT术语的定义都来源于国外，我们看的中文大部分是别人看了国外的文献然后以他的中文素养加以解释的！但是中华语言博大精深！而英语就较为简单了，记得上次看高德纳的《surreal number》时候，文中有一句“the beginning of the world”,而作者译为“万物初始”，从这里就可见一斑了！所以，对于一些不是很明白的IT术语，可以去看一下英文翻译，可能会对你有帮助)递归的英文是recursion，有循环的意思。
能够形成函数递归，该函数要有两个属性：
1.A simple base case (or cases), and
2.A set of rules which reduce all other cases toward the base case.
For example, the following is a recursive definition of a person's ancestors:
One's parents are one's ancestors (base case).
The parents of one's ancestors are also one's ancestors (recursion step).
The Fibonacci sequence is a classic example of recursion:
Fib(0) is 0 [base case]
Fib(1) is 1 [base case]
For all integers n > 1: Fib(n) is (Fib(n-1) + Fib(n-2)) [recursive definition]
楼上的同志将递归的定义解释得已经很清楚了，但是你想要真正了解什么是函数递归，最好先了解什么是递归！然后对于函数递归就豁然开朗了！
递归就是在过程或函数里调用自身。在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
int rev(int i)
{
if(i<5) rev(i++);
else return i;
}
int rev(int i)
{
if(i<5) rev(i++);
else return i;
}
所谓递归，说的简单点，就是函数自己调用自己，然后在某个特定条件下。结束这种自我调用。
如果不给予这个结束条件，就成了无限死循环了。这样这个递归也就毫无意义了。
如下面问题
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个数了。
何时考虑使用递归。
当你分析一个问题的时候，发现这个问题，是一个自我循环时，而且这个自我循环到一个给定值，就可以终止的时候，你就快要考虑递归了。

c语言，求这道题用递归函数的答案题目如图

递归，就是在运行的过程中调用自己。
构成递归需具备的条件：
函数嵌套调用过程示例
1. 子问题须与原始问题为同样的事，且更为简单；
2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。
在数学和计算机科学中，递归指由一种（或多种）简单的基本情况定义的一类对象或方法，并规定其他所有情况都能被还原为其基本情况。
例如，下列为某人祖先的递归定义：
某人的双亲是他的祖先（基本情况）。某人祖先的双亲同样是某人的祖先（递归步骤）。斐波纳契数列（Fibonacci Sequence），又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21..... I[1]
斐波纳契数列是典型的递归案例：
递归关系就是实体自己和自己建立关系。
Fib(0) = 1 [基本情况] Fib(1) = 1 [基本情况] 对所有n > 1的整数：Fib(n) = (Fib(n-1) + Fib(n-2)) [递归定义] 尽管有许多数学函数均可以递归表示，但在实际应用中，递归定义的高开销往往会让人望而却步。例如：
阶乘（1) = 1 [基本情况] 对所有n > 1的整数：阶乘（n) = (n * 阶乘（n-1)) [递归定义] 一种便于理解的心理模型，是认为递归定义对对象的定义是按照“先前定义的”同类对象来定义的。例如：你怎样才能移动100个箱子？答案：你首先移动一个箱子，并记下它移动到的位置，然后再去解决较小的问题：你怎样才能移动99个箱子？最终，你的问题将变为怎样移动一个箱子，而这时你已经知道该怎么做的。
如此的定义在数学中十分常见。例如，集合论对自然数的正式定义是：1是一个自然数，每个自然数都有一个后继，这一个后继也是自然数。
德罗斯特效应是递归的一种视觉形式。图中女性手持的物体中有一幅她本人手持同一物体的小图片，进而小图片中还有更小的一幅她手持同一物体的图片，依此类推。
德罗斯特效应
又例如，我们在两面相对的镜子之间放一根正在燃烧的蜡烛，我们会从其中一面镜子里看到一根蜡烛，蜡烛后面又有一面镜子，镜子里面又有一根蜡烛……这也是递归的表现。

c语言函数递归调用问题（请高手帮忙详细解释）

看到这么多疑问我敢肯定一点，你并没有真正意识到什么叫递归程序?这个程序不是一个很简单的程序，如果搞不清递归的详细定义，即使你明白了这个程序，也是勉强，如果想彻底了解到递归，必须了解它的定义，思路清晰后再看这道题就很简单了，相信你自己也可以独自解析这个程序。我下面有一个图还是比较简单明了的介绍递归的，可以参考下。
如果只有一个盘，直接把它从one移到three位置;若有n个盘，就假设有n-1个可以知道怎么移，那么把上边n-1个盘从one移到two位置，再把最底第n个盘从one移到three位置，最后把其余n-1个从two移到three位置。问题就解决了。
对于n-1可以依靠n-2解决，以此类推，直到2个盘时可以依靠1个盘的解决方法，到1个盘时，已经给出了解决方法。这就是递归的思想，类似于数学的归纳法。
buhui
pp
确实，初学C的时候，汉诺塔的递归看起来确实是比较神奇的程序。
其中主要就在hanoi 这个递归函数，传的参数里面有一个n 代表是几层递归。
如果n=1 代表只有一个，move(one,three); 就是把第一个移到第三个就行了。否则
第一个柱子上有n个(n>1) 要移到第三个。需要把上面的n-1个移到第二个，最下面的一个移到第三个，再把第二个柱子上的n-1个移到第三个。 要这三个步骤。
其中，第一个，和第三个步骤，和本身其实是一样的。
就是把n-1个移到第二个，注意hanoi的参数
/* 定义hanoi函数,将n个盘从one座借助two座，移到three座 */
two 即第二个参数，这是表示用来借助的
就假设n=2 吧 hanoi(2,'A','B','C'); 变成了
hanoi(1,A,C,B); //这个代表A座上有一块，需要借助C座，移到B座
A--->C
hanoi(1,B,A,C); //这个代表B座上有一块，需要借助A座，移到C座
最后会输出
A-->B
A-->C
B-->C
假设n=3 hanoi(3,'A','B','C');
hanoi(2,A,C,B); //这个代表A座上有两块，需要借助C座，移到B座
A--->C
hanoi(2,B,A,C); //这个代表B座上有两块，需要借助A座，移到C座
A座上有两块，需要借助C座，移到B座 会输出
A-->C
A-->B
C-->B
B座上有两块，需要借助A座，移到C座 会输出
B-->A
B-->C
A-->C