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

c语言递归详解,c语言中，什么是函数的递归，能举个例子么详细介绍

本文目录一览： c语言，函数递归，求详解

程序调用自身的编程技巧称为递归（ recursion）。　
　一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。　
　注意：　　
(1) 递归就是在过程或函数里调用自身； 　
(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口

C语言，递归函数？

对于这段代码，fun 函数是一个递归函数。让我们分析一下递归调用的过程，以便理解为什么第一个输出是 -1。
当从 main 函数调用 fun(20) 时，进入 fun 函数，由于 x / 2 > 0（20 / 2 = 10 > 0），所以递归调用 fun(20 / 2 - 2)，即 fun(8)。
再次进入 fun 函数，这次 x 为 8，仍然满足 x / 2 > 0（8 / 2 = 4 > 0），再次递归调用 fun(8 / 2 - 2)，即 fun(2)。
再次进入 fun 函数，这次 x 为 2，仍然满足 x / 2 > 0（2 / 2 = 1 > 0），再次递归调用 fun(2 / 2 - 2)，即 fun(-1)。
这次进入 fun 函数，x 为 -1，x / 2 > 0 的条件不满足（-1 / 2 = -1，-1 不大于 0），所以不再进行递归调用。然后，执行 printf("%d ", x); 语句，输出 -1。
2/2 1 1大于0 还是会进入fun方法 在fun方法中 2/2-2 等于-1
后在场进入 fun 方法 (-1/2>0) 然后依次打印X的值
这段代码中定义了一个递归函数 fun，函数的功能是将输入的参数 x 以二进制形式输出到控制台。具体来说，函数 fun 的实现过程如下：
判断 x/2 是否大于 0，如果成立，则执行下一步操作，否则直接输出 x 的值。
调用 fun(x/2-2)，即递归调用自身，将 x/2-2 作为新的参数传递给 fun 函数。
输出 x 的二进制表示。由于在递归调用后，程序会一直执行到当前调用结束，所以输出的顺序是从最高位到最低位。
根据上述描述，当 fun(20) 被调用时，函数将按照如下顺序执行：
fun(20) 调用 fun(8)，输出 1。
fun(8) 调用 fun(2)，输出 0。
fun(2) 调用 fun(0)，输出 1。
fun(0) 直接输出 0。
因此，最终的输出结果为：10100，即二进制下的 20。
因此，选项 B) 2820 是正确答案。

C语言什么是递归

递归方法的概念
类方法成员间允许相互调用，也可以自己调用自己。类的方法如果在方法体内直接或间接地自己调用自己就称为递归方法。
递归基本思想就是“自己调用自己”。递归方法实际上体现了“依此类推”、“用同样的步骤重复”这样的思想，它可以用简单的程序来解决某些复杂的计算问题。
递归调用在完成阶乘运算、级数运算、幂指数运算等方面特别有效。
在执行递归操作时，C#语言把递归过程中的信息保存在堆栈中。如果无限循环地递归，或者递归次数太多，则产生“堆栈溢出”错误
例：用递归方法求阶乘。利用的数学公式为n!=n*(n-1)!。当n=0时，n!=1。
代码如下：
public long F(int n)
{
if (n==1)
return 1;
else
return n*F(n-1);
}

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语言递归函数

递归求
阶乘
的吧,不过你写的有问题，函数既然接受
形参
n，在函数里就不用再读取了；而且函数返回的是long类型，应该
强制转换
返回值
。
这样吧,你不要管什么递归,你自己想一下,不用递归,怎么解这个问题,最后得出的思路肯定就恰好是递归的过程
这个是要用图来说明的…一画图什么都明白了
对于递归，我打个比方吧！
就像一根缠绕着的铁链，知道从第一个环就能解开，但是现在只能拿到最后一个环，所以就必须从最后一个环顺着链条往头找，直到找到第一个，就相当于找到递归的跳出条件了
例子不是很恰当
不明白的话，留言，一定给你讲清楚…留言比回
这是道汉诺塔的题目
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
意思是说
1）如果我把上面的 n-1个元素放到第二个柱子上
2）那么我就可以把最下面的棋子放到第三个柱子上
3）然后我再把第二个柱子上的n-1个棋放到第三个柱子上
第二个参数是源地址，第四个参数是目标地址，第三个参数是暂存地址。
分成三组：
(一)，
目的：将1号和2号从A移到B
调用函数：hanoi(2,'A', 'C', 'B')。
在hanoi(2,'A', 'C', 'B')中递归调用如下：
A-->C----hanoi(1,'A', 'B', 'C')
A-->B----hanoi(1,'A', 'C', 'B')
C-->B----hanoi(1,'C', 'A', 'B')
(二)，
目的：将3号从A移到C
调用函数：hanoi(1,'A', 'B', 'C')
A-->C
(三)，
目的：将1号和2号从B移到C
调用函数：hanoi(2,'B', 'A', 'C')
在hanoi(2,'B', 'A', 'C')中递归递归如下：
B-->A----hanoi(1,'B', 'C', 'A')
B-->C----hanoi(1,'B', 'A', 'C')
A-->C----hanoi(1,'A', 'B', 'C')
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
总共调用了7次函数，
只要hanoi()的第一个参数大于1，它就会在内部调用自身3次，“直到第一个参数＝1，然后调用printf()”。
hanoi(n, ...)调用hanoi(1, ...)的次数为2的n次方减去一。
　　递归函数：
　　编程语言中，函数Func(Type a,……)直接或间接调用函数本身，则该函数称为递归函数。递归函数不能定义为内联函数。
　　在数学上，关于递归函数的定义如下：对于某一函数f(x)，其定义域是集合A，那么若对于A集合中的某一个值X0，其函数值f(x0)由f(f(x0))决定，那么就称f(x)为递归函数。
　　函数介绍：
　　在数理逻辑和计算机科学中，递归函数或μ-递归函数是一类从自然数到自然数的函数，它是在某种直觉意义上是"可计算的" 。事实上，在可计算性理论中证明了递归函数精确的是图灵机的可计算函数。递归函数有关于原始递归函数，并且它们的归纳定义(见下)建造在原始递归函数之上。但是，不是所有递归函数都是原始递归函数 — 最著名的这种函数是阿克曼函数。
　　其他等价的函数类是λ-递归函数和马尔可夫算法可计算的函数。
　　例子：
　　//代码1
　　void func()
　　{
　　//...
　　if(...)
　　func();
　　else
　　//...
　　}
　　条件：
　　一个含直接或间接调用本函数语句的函数被称之为递归函数，在上面的例子中能够看出，它必须满足以下两个条件：
　　1） 在每一次调用自己时，必须是（在某种意义上）更接近于解；
　　2） 必须有一个终止处理或计算的准则。
　　梵塔的递归函数：
　　//C
　　void 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语言中什么叫递归

就是一样了送回来了
在一个函数里存在函数本身，这样只要没达到要求，就会一直调用函数本身，这个就是递归函数的意思。
递归：就是自己调自己，但是没终止条件会死循环，所以你的递归代码里有结束自调自的条件，这样就创造了有限次的循环（代码中你看不到for或foreach但是有循环发生）

讲一下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语言 函数的递归调用问题 这个地方没怎么学明白 求给个详细的过程 谢谢了

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语言怎样用递归方法编写程序 求s＝1！+2！+3！+...10!

#include

int n,t=1,s=0;

void sum_fac(int k)

{if(k<=n)

{s+=t;

t*=k;

sum_fac(k+1);

}

}

int main ()

{ scanf("%d",&n);

sum_fac(1);

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

return 0;

}

c语言代码如下：

int fun(int n){

int i,sum=1;

if(n==1)

return 1;

else

{

for (i=1;i<=n;i++)

sum=sum*i;

}

return sum+fun(n-1);

}

int main(){

printf("%ld",fun(10));

return 0;

}

结果：

下面是测试的结果：

测试结果

思路：先通过程序获得阶乘的值，之后再将阶乘相加，求阶乘时和相加时都用递归的写法

首先是求阶乘：

int factorial(int index){

int sum = 0;

if (index == 1){

sum = 1;

}else{

sum = index * factorial(index-1);

}

return sum;

}

之后再求和：

int add_recursion(int maxnum){

int sum = 0;

if (maxnum == 1){

sum = factorial(maxnum);

}else{

sum = factorial(maxnum) + add_recursion(maxnum-1);

}

return sum;

}

下面是完整的代码：

完整代码

C语言 递归调用中是如何实现求最值的？ 递归调用在return语句前，怎么返回？ 帮忙解释一下，谢

从代码可以知道，当n=1时，返回a[0]，在n>1的时候，首先调用f(a, n-1)，得到t，然后让这个t和a[n-1]进行比较，如果t>a[n-1]就返回t的值，否则返回a[n-1]的值，递归调用时会先到n=1的时候得到t=a[0]，退出到调用的地方，该地方n=2, 用t和a[1]比较，返回较大值，退出到上一个调用的地方，该地方n=3，然后用这个较大值和a[2]比较，依次类推，退出到main函数时即得到了最大值。
这就是一个很正常的递归调用。
要理解递归的执行过程，告诉你一个方法：
在函数f的第一个语句前加上printf("begin:%d\n",n);
在return之前加上printf("end return:%d\n",n); //（注意大括号）
这样执行后你就知道实际的执行顺序了，跟着打印出来的慢慢分析，就可以理解递归的实际过程。