比如说,用递时方法求n!.
我一点概念都没有,大虾们帮帮可怜的小妹吧!难道学TC真的那么难吗?
24 个解决方案
#1
result=n*fun(n-1);
难道学TC真的那么难吗? //不是tc,而是c语言
难道学TC真的那么难吗? //不是tc,而是c语言
#2
递归很重要吗?
我不觉得,
效率很差的
我不觉得,
效率很差的
#3
递归是很重要的。
效率差、受限制,是递归的缺点不错,但是可以用一些编程技巧加以改善。
递归算法再某些情况下可以有效降低算法的描述难度,提升算法清晰度,甚至有一些问题根本没有非递归的解法。
效率差、受限制,是递归的缺点不错,但是可以用一些编程技巧加以改善。
递归算法再某些情况下可以有效降低算法的描述难度,提升算法清晰度,甚至有一些问题根本没有非递归的解法。
#4
result=n*fun(n-1);
我不懂~~~~~~~~
我不懂~~~~~~~~
#5
遇到这类问题先考虑结束条件,在考虑参数,再考虑每次应反回什么
#6
其实如果学过 数学归纳法,我认为递归是不难理解的。
随便找一个数学归纳法的证明题,也会比楼主这个问题复杂很多。归纳法不就是用递归的思想证明问题么。
随便找一个数学归纳法的证明题,也会比楼主这个问题复杂很多。归纳法不就是用递归的思想证明问题么。
#7
天啊,我是数学白痴,我不知道什么归纳法,5555555555
#8
因为:n!=n*(n-1)!=n*(n-1)*(n-2)!=.....
所以:fun(n)=n*fun(n-1)
int fun(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
所以:fun(n)=n*fun(n-1)
int fun(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
#9
建议你还是不要学理了
#10
递归:有一个数I,你给他加一,就是I=+1,然后你把这两个数乘起来就是I*(I+1),将这个数的值赋给I,就是I=I*(I+1),再将这个新的I,加1,就是I(新的)+1,再将他们乘起来,
I(新的)*I(新的)+1。以此类推,
I(新的)*I(新的)+1。以此类推,
#11
int fun(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
但是这段代码中交没有哪有说了要加什么的呀,我只看见有个n-1.我就是不懂n*fun(n-1);
这是什么意思?
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
但是这段代码中交没有哪有说了要加什么的呀,我只看见有个n-1.我就是不懂n*fun(n-1);
这是什么意思?
#12
多学学数学吧
#13
n*fun(n-1)和我上面说的差不多,只是加变了减。
n就是我所说的I,fun(n-1)就是I+1,表达的不好,你看着理解吧。
n就是我所说的I,fun(n-1)就是I+1,表达的不好,你看着理解吧。
#14
看见那么多人热心地帮你,你就尽力吧!
好感人的场面哦!
好感人的场面哦!
#15
/* 我就是不懂n*fun(n-1);
这是什么意思? */
我们用函数fun(n) 求n!,则fun(n-1)的结果就是(n-1)!
这是什么意思? */
我们用函数fun(n) 求n!,则fun(n-1)的结果就是(n-1)!
#16
当编译器执行n*fun(n-1)指令时,编译器一遇到fun(n-1),它就知道再重新进入函数体内,执行函数的指令,只不过这时函数的参数变成了(n-1),当再次进入函数体内时,编译器又遇到n*fun(n-1)这条指令,但需要注意的是这时的n实际上是(n-1),因为进入函数体内的参数是(n-1),然后编译器又遇到n*fun(n-1)指令,又重新进入函数体,就这样在函数体内当碰到
fun(n-1)时,编译器就又回到函数开始的地方,继续往下做,就相当于函数不停的自己调用自己,只不过它每自己调用自己一次,它下一次进入它自己体内的参数就要减1,所以结果就相当于n(第一次),n*(n-1)(第二次),n*(n-1)*(n-2)(第三次)。。。。。。直到n减到1为止,执行if语句的指令,明白了吧!
fun(n-1)时,编译器就又回到函数开始的地方,继续往下做,就相当于函数不停的自己调用自己,只不过它每自己调用自己一次,它下一次进入它自己体内的参数就要减1,所以结果就相当于n(第一次),n*(n-1)(第二次),n*(n-1)*(n-2)(第三次)。。。。。。直到n减到1为止,执行if语句的指令,明白了吧!
#17
你这是横向思维,你用垂直思维想一下!
fun(n)是求n!fun(n-1)也是求(n-1)!
n 与 n-1 其实是一回事 参数!
但就固定的n来说 从fun(n)开始 垂直方向不就传下去了吗?
fun(n)是求n!fun(n-1)也是求(n-1)!
n 与 n-1 其实是一回事 参数!
但就固定的n来说 从fun(n)开始 垂直方向不就传下去了吗?
#18
对啊,它实际上就是说每调用一次函数得到一个值
比如说第一次调用得到n,第二次得到(n-1),依次类推,最后得到1,中间用乘号连接。
实际上就相当于用一个for循环求值。每一次调用就相当于一次循环过程。
for(int i=1;i<=n;i++)
{
int result=1;
result=result*i;
}
比如说第一次调用得到n,第二次得到(n-1),依次类推,最后得到1,中间用乘号连接。
实际上就相当于用一个for循环求值。每一次调用就相当于一次循环过程。
for(int i=1;i<=n;i++)
{
int result=1;
result=result*i;
}
#19
你真厉害
不会递归居然知道还有个csdn。net
说明你很有潜质。
记住,脸皮要厚,胆子要大,脑子要活!
如此就ok了
不会递归居然知道还有个csdn。net
说明你很有潜质。
记住,脸皮要厚,胆子要大,脑子要活!
如此就ok了
#20
现在计算机计算能力很强,程序的可读性很重要,递归能很好的简化程序。
#21
long f(long n)
{
if(n<=1)return n;
return n*f(n-1);
}
递归一般就是不断重复调用自己, 是便于思考,怎么会头昏?
就如n! :就是求n * (n-1)!
上面f()就是求n的阶层,
f(n)=n*f(n-1)=n*(n-1)*f(n-1-1)=....... 当n=1时,让f()=1就搞定了。
加分!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
{
if(n<=1)return n;
return n*f(n-1);
}
递归一般就是不断重复调用自己, 是便于思考,怎么会头昏?
就如n! :就是求n * (n-1)!
上面f()就是求n的阶层,
f(n)=n*f(n-1)=n*(n-1)*f(n-1-1)=....... 当n=1时,让f()=1就搞定了。
加分!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#22
算法的递归次数有限制,深度不宜太深
int factorial(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
int factorial(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
#23
就是一个数*它本身少一点
呵呵
这样明白不?
听 TopCat(令狐虫) 的没错
人家是高手
我也是初学者呃
呵呵
大家一努力呃
呵呵
这样明白不?
听 TopCat(令狐虫) 的没错
人家是高手
我也是初学者呃
呵呵
大家一努力呃
#24
看个非波那切数(可能中文不对,仅仅是音译)的递归程序,如果看不懂,那说实话真的。。。
#1
result=n*fun(n-1);
难道学TC真的那么难吗? //不是tc,而是c语言
难道学TC真的那么难吗? //不是tc,而是c语言
#2
递归很重要吗?
我不觉得,
效率很差的
我不觉得,
效率很差的
#3
递归是很重要的。
效率差、受限制,是递归的缺点不错,但是可以用一些编程技巧加以改善。
递归算法再某些情况下可以有效降低算法的描述难度,提升算法清晰度,甚至有一些问题根本没有非递归的解法。
效率差、受限制,是递归的缺点不错,但是可以用一些编程技巧加以改善。
递归算法再某些情况下可以有效降低算法的描述难度,提升算法清晰度,甚至有一些问题根本没有非递归的解法。
#4
result=n*fun(n-1);
我不懂~~~~~~~~
我不懂~~~~~~~~
#5
遇到这类问题先考虑结束条件,在考虑参数,再考虑每次应反回什么
#6
其实如果学过 数学归纳法,我认为递归是不难理解的。
随便找一个数学归纳法的证明题,也会比楼主这个问题复杂很多。归纳法不就是用递归的思想证明问题么。
随便找一个数学归纳法的证明题,也会比楼主这个问题复杂很多。归纳法不就是用递归的思想证明问题么。
#7
天啊,我是数学白痴,我不知道什么归纳法,5555555555
#8
因为:n!=n*(n-1)!=n*(n-1)*(n-2)!=.....
所以:fun(n)=n*fun(n-1)
int fun(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
所以:fun(n)=n*fun(n-1)
int fun(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
#9
建议你还是不要学理了
#10
递归:有一个数I,你给他加一,就是I=+1,然后你把这两个数乘起来就是I*(I+1),将这个数的值赋给I,就是I=I*(I+1),再将这个新的I,加1,就是I(新的)+1,再将他们乘起来,
I(新的)*I(新的)+1。以此类推,
I(新的)*I(新的)+1。以此类推,
#11
int fun(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
但是这段代码中交没有哪有说了要加什么的呀,我只看见有个n-1.我就是不懂n*fun(n-1);
这是什么意思?
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
但是这段代码中交没有哪有说了要加什么的呀,我只看见有个n-1.我就是不懂n*fun(n-1);
这是什么意思?
#12
多学学数学吧
#13
n*fun(n-1)和我上面说的差不多,只是加变了减。
n就是我所说的I,fun(n-1)就是I+1,表达的不好,你看着理解吧。
n就是我所说的I,fun(n-1)就是I+1,表达的不好,你看着理解吧。
#14
看见那么多人热心地帮你,你就尽力吧!
好感人的场面哦!
好感人的场面哦!
#15
/* 我就是不懂n*fun(n-1);
这是什么意思? */
我们用函数fun(n) 求n!,则fun(n-1)的结果就是(n-1)!
这是什么意思? */
我们用函数fun(n) 求n!,则fun(n-1)的结果就是(n-1)!
#16
当编译器执行n*fun(n-1)指令时,编译器一遇到fun(n-1),它就知道再重新进入函数体内,执行函数的指令,只不过这时函数的参数变成了(n-1),当再次进入函数体内时,编译器又遇到n*fun(n-1)这条指令,但需要注意的是这时的n实际上是(n-1),因为进入函数体内的参数是(n-1),然后编译器又遇到n*fun(n-1)指令,又重新进入函数体,就这样在函数体内当碰到
fun(n-1)时,编译器就又回到函数开始的地方,继续往下做,就相当于函数不停的自己调用自己,只不过它每自己调用自己一次,它下一次进入它自己体内的参数就要减1,所以结果就相当于n(第一次),n*(n-1)(第二次),n*(n-1)*(n-2)(第三次)。。。。。。直到n减到1为止,执行if语句的指令,明白了吧!
fun(n-1)时,编译器就又回到函数开始的地方,继续往下做,就相当于函数不停的自己调用自己,只不过它每自己调用自己一次,它下一次进入它自己体内的参数就要减1,所以结果就相当于n(第一次),n*(n-1)(第二次),n*(n-1)*(n-2)(第三次)。。。。。。直到n减到1为止,执行if语句的指令,明白了吧!
#17
你这是横向思维,你用垂直思维想一下!
fun(n)是求n!fun(n-1)也是求(n-1)!
n 与 n-1 其实是一回事 参数!
但就固定的n来说 从fun(n)开始 垂直方向不就传下去了吗?
fun(n)是求n!fun(n-1)也是求(n-1)!
n 与 n-1 其实是一回事 参数!
但就固定的n来说 从fun(n)开始 垂直方向不就传下去了吗?
#18
对啊,它实际上就是说每调用一次函数得到一个值
比如说第一次调用得到n,第二次得到(n-1),依次类推,最后得到1,中间用乘号连接。
实际上就相当于用一个for循环求值。每一次调用就相当于一次循环过程。
for(int i=1;i<=n;i++)
{
int result=1;
result=result*i;
}
比如说第一次调用得到n,第二次得到(n-1),依次类推,最后得到1,中间用乘号连接。
实际上就相当于用一个for循环求值。每一次调用就相当于一次循环过程。
for(int i=1;i<=n;i++)
{
int result=1;
result=result*i;
}
#19
你真厉害
不会递归居然知道还有个csdn。net
说明你很有潜质。
记住,脸皮要厚,胆子要大,脑子要活!
如此就ok了
不会递归居然知道还有个csdn。net
说明你很有潜质。
记住,脸皮要厚,胆子要大,脑子要活!
如此就ok了
#20
现在计算机计算能力很强,程序的可读性很重要,递归能很好的简化程序。
#21
long f(long n)
{
if(n<=1)return n;
return n*f(n-1);
}
递归一般就是不断重复调用自己, 是便于思考,怎么会头昏?
就如n! :就是求n * (n-1)!
上面f()就是求n的阶层,
f(n)=n*f(n-1)=n*(n-1)*f(n-1-1)=....... 当n=1时,让f()=1就搞定了。
加分!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
{
if(n<=1)return n;
return n*f(n-1);
}
递归一般就是不断重复调用自己, 是便于思考,怎么会头昏?
就如n! :就是求n * (n-1)!
上面f()就是求n的阶层,
f(n)=n*f(n-1)=n*(n-1)*f(n-1-1)=....... 当n=1时,让f()=1就搞定了。
加分!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#22
算法的递归次数有限制,深度不宜太深
int factorial(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
int factorial(int n)
{
if(n==1|n==0)return 1;
return n*fun(n-1);
}
#23
就是一个数*它本身少一点
呵呵
这样明白不?
听 TopCat(令狐虫) 的没错
人家是高手
我也是初学者呃
呵呵
大家一努力呃
呵呵
这样明白不?
听 TopCat(令狐虫) 的没错
人家是高手
我也是初学者呃
呵呵
大家一努力呃
#24
看个非波那切数(可能中文不对,仅仅是音译)的递归程序,如果看不懂,那说实话真的。。。