递归算法求n的阶乘,c语言递归求阶乘

递归算法求n的阶乘,c语言递归求阶乘详细介绍

本文目录一览： n的阶乘公式

公式:n!=n*(n-1)!
阶乘的计算方法
阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。
例如所要求的数是4，则阶乘式是1×2×3×4，得到的积是24，24就是4的阶乘。 例如所要求的数是6，则阶乘式是1×2×3×..×6，得到的积是720，720就是6的阶乘。例如所要求的数是n，则阶乘式是1×2×3×…×n，设得到的积是x，x就是n的阶乘。
阶乘的表示方法
在表达阶乘时，就使用“！”来表示。如x的阶乘，就表示为x!
他的原理就是反推，如，举例，求10的阶乘=10*9的阶乘（以后用!表示阶乘）那么9!=？，9!=9*8!,8!=8*7!,7!=7*6!,6!=6*5!,5!=5*4!,4!=4*3!,
3!=3*2!,2!=2*1!,1的阶乘是多少呢？是1 1!=1*1,数学家规定，0!=1,所以0!=1!然后在往前推算，公式为n！(n!为当前数所求的阶乘)=n(当前数)*(n-1)!（比他少一的一个数N-1的阶乘把公式列出来像后推，只有1的!为1，所以要从1开始，要知道3！要知道2！就要知道1！但必须从1!开始推算所以要像后推，如果遍程序算法可以此公式用一个函数解决，并且嵌套调用次函数，，）把数带入公式为, 1!=1*1 2!=2*1(1!) 3!=3*2(2!) 4=4*6(3!),如果要是编程，怎么解决公式问题呢
首先定义算法
//算法，1，定义函数，求阶乘，定义函数fun,参数值n，（#include

long fun(int n ) //long 为长整型，因20！就很大了超过了兆亿

（数学家定义数学家定义，0！=1，所以0！=1！，0与1的阶乘没有实际意义）

2，函数体判断，如果这个数大于1，则执行if(n>1)（往回退算，这个数是10求它!,要从2的阶乘值开始，所以执行公式的次数定义为9，特别需要注意的是此处，当前第一次写入代码执行，已经算一次）

求这个数的n阶乘（公式为，n！=n*(n-1)！，并且反回一个值，

return (n*(fun(n-1));(这个公式为，首先这个公式求的是10的阶乘，但是求10的阶乘就需要，9的阶乘，9的阶乘我们不知道，所以就把10减1，也就是n-1做为一个新的阶乘，从新调用fun函数，求它的阶乘然后在把这个值返回到 fun(n-1),然后执行n*它返回的值，其实这个公式就是调用fun函数的结果，函数值为return 返回的值，（n-1）为参数依次类推，...一值嵌套调用fun函数，

到把n-1的值=1,

注意：此时已经运行9次fun（）函数算第一次运行，，调用几次fun函数呢？8次函数，所以，n-1执行了9次，n-1=1 ，n=2已经调用就可以求2乘阶值

n!=1×2×3×...×n或者0!=1，n!=(n-1)!×n

例如，求1x2x3x4...xn的值，此时可以用阶乘的方式表示：

n!=1×2×3×...×（n-1)n或者n!=(n-1)!×n

扩展资料一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的

阶乘写作n!。1808年，基斯顿·卡曼引进这个表示法。阶乘常用于计算机领域。

大于等于1

任何大于等于1 的自然数n 阶乘表示方法:

n!=1×2×3×...×（n-1）n或n!=(n-1)!×n0的阶乘

其中0！=1

参考资料：百度百科-阶乘

n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n。

阶乘是基斯顿·卡曼（Christian Kramp，1760～1826）于 1808 年发明的运算符号，是数学术语。

一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。1808年，基斯顿·卡曼引进这个表示法。

扩展资料

严谨的阶乘定义应该为：对于数n，所有绝对值小于或等于n的同余数之积。称之为n的阶乘，即n!

对于复数应该是指所有模n小于或等于│n│的同余数之积。。。对于任意实数n的规范表达式为：

正数 n=m+x,m为其正数部，x为其小数部

负数n=-m-x,-m为其正数部，-x为其小数部

参考资料：百度百科阶乘词条

1、当n=0时，n！=0！=1

2、当n为大于0的正整数时，n！=1×2×3×…×n

一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积。自然数n的阶乘写作n!。该概念于1808年由数学家基斯顿·卡曼引进。

通常我们所说的阶乘是定义在自然数范围里的（大多科学计算器只能计算 0～69 的阶乘），小数科学计算器没有阶乘功能，如 0.5！，0.65！，0.777！都是错误的

扩展资料0的阶乘

由于正整数的阶乘是一种连乘运算，而0与任何实数相乘的结果都是0。所以用正整数阶乘的定义是无法推广或推导出0！=1的。即在连乘意义下无法解释“0！=1”。

给“0！”下定义只是为了相关公式的表述及运算更方便。 它只是一种定义出来的特殊的“形式”上的阶乘记号，无法用演绎方法来论证。“为什么0！=1”这个问题是伪问题。

这个问题通常可以应用幂级数得到简单的解决。

具体有：

sin x=x-x三次方/3!+x五次方/5!-...(其中，3!为3的阶乘，3!=1×2×3，依次类推）

cos x=1-x二次方/2!+x三次方/3!-...

这里的未知数x为孤度制，不能采用角度制。

这两个式子均为无穷级数，采用的项数越多，得出的数值越精确。

不知道你的数学学习到什么程度，这样给你讲不知道能不能理解。在百度这种编辑窗口之中，给你这样回答实在是勉为其难，许多符号不能输入，不知道你能不能看得懂。

大学微积分课之中有“幂级数”这一章节

n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n。

亦即n!=1×2×3×...×n。阶乘亦可以递归方式定义：0!=1，n!=(n-1)!×n。

扩展资料双阶乘用“m！！”表示。

当 m 是自然数时，表示不超过 m 且与 m 有相同奇偶性的所有正整数的乘积。如：

当 m 是负奇数时，表示绝对值小于它的绝对值的所有负奇数的绝对值积的倒数。

当 m 是负偶数时，m！！不存在。

任何大于等于1 的自然数n 阶乘表示方法：

资料来源：阶乘_百度百科

由递归方式求的N的阶乘（即N，），时间复杂度是多少

每次递归内部计算时间是常数，故O（n）。
用递归方法计算阶乘，函数表达式为f(n)=1 若n=0 f(n)=n*f(n-1)，若n>0，如果n=0，就调用1次阶乘函数，如果n=1，就调用2次阶乘函数，如果n=2，就调用3次阶乘函数，如果n=3，就调用4次阶乘函数。
扩展资料：
注意事项：
利用递归树方法求算法复杂度，其实是提供了一个好的猜测，简单而直观。在递归树中每一个结点表示一个单一问题的代价，子问题对应某次递归函数调用，将树中每层中的代价求和，得到每层代价，然后将所有层的代价求和，得到所有层次的递归调用总代价。
递归树最适合用来生成好的猜测，然后可用代入法来验证猜测是否正确。当使用递归树来生成好的猜测时，常常要忍受一点儿不精确，因为关注的是如何寻找解的一个上界。
参考资料来源：百度百科-递归算法
参考资料来源：百度百科-阶乘
参考资料来源：百度百科-时间复杂度

C语言怎么用递归法求阶乘

1、首先打开vc6.0，新建一个vc项目。
2、接下来需要添加头文件。
3、添加main主函数。
4、定义一个用来求阶乘的函数。
5、在main函数定义int类型变量sum。
6、调用fact()，并将返回值赋予sum。
7、使用printf打印sum。
8、运行程序，看看结果。
思路分析：
n!
=
n*(n-1)!
//
n的阶乘可以化为n乘以(n-1)
的阶乘，这就是递归
当n=0或1时，n!
=
1
//
这就是递归终止条件
实现算法程序：
double fun(int n) // 递归函数求n的阶乘
{
if(n==0 || n==1) // 递归终止条件
return 1;
else
return n*fun(n-1); // 进行递归运算
}
没错按道理来说是
不满足
条件
(n>1)
时才执行
return
1;
加上
else
程序看起来更清楚。
可是
因为
满足
条件
(n>1)
时执行的是
return
(n*fun(n-1));
就已经退出函数了
所以
else
就可以省略了，只有
不满足
条件
(n>1)
时才会执行到
return
1;
n的阶乘，就是从1开始乘到n,即1*2*3*...*(n-1)*n。
即n!=1*2*3*...*(n-1)*n。
而(n-1)!=1*2*3*...*(n-1)。
所以可以得出，n!=(n-1)!
*
n。
由这个概念，可以得出递归求阶乘函数fact的算法：
1
如果传入参数为0或1，返回1；
2
对于任意的n，返回n*fact(n-1)。
代码如下：
int fact(int n)
{
if(n == 0 || n == 1) return 1;
return n*(fact(n-1));
}

用递归编程方法求n的阶乘n！

思路：递归求阶乘函数，如果输入的参数等于1则返回1，否则返回n乘以该函数下次递归。
参考代码：
#include
int fun(int n)
{
if(n==1||n==0) return 1;//如果参数是0或者1返回1
return n*fun(n-1);//否则返回n和下次递归的积
}
int main()
{
int n;
scanf("%d",&n);
printf("%d\n",fun(n));
return 0;
}
/*
5
120
*/
【递归算法的原理】
递归是计算机科学的一个重要概念,递归的方法是程序设计中有效的方法,采用递归编写
递归能使程序变得简洁和清晰。

c语言递归求阶乘

n的阶乘，就是从1开始乘到n,即1*2*3*...*(n-1)*n。
即n!=1*2*3*...*(n-1)*n。
而(n-1)!=1*2*3*...*(n-1)。
所以可以得出，n!=(n-1)! * n。
由这个概念，可以得出递归求阶乘函数fact的算法：
1 如果传入参数为0或1，返回1；
2 对于任意的n，返回n*fact(n-1)。
代码如下：
int fact(int n){ if(n == 0 || n == 1) return 1; return n*(fact(n-1));}
递归求阶乘
第二个就是主函数啊，它用10调用了fun函数，就是求10的阶乘，输出为10!=3628800。
第一个return求的是n>1时的阶乘，这样一层一层地找下去，处理递归并返回结果。第二个return前面省略了else，也就是当不满足n>1这个条件时执行的，是判断递归的边界，返回的是1的阶乘的答案，如果没有这个return，递归就没有边界，一直进行下去，就会造成栈溢出。
PS：我也是刚学，说的可能不是很好，希望对你有帮助！
n>1的时候递归下去 如果等于1直接返回1
举例：用递归方法求n；
#include

int main()

{

int n;

int y;

printf("input a integer number:");

scanf("%d",&n);

y=fac(n);

printf("%d!=%d\n",n,y);

return 0;

}

int fac(int n)

{

int f;

if(n<0)

printf("n<0,data error!");

else if(n==0||n==1)

f=1;

else

f=fac(n-1)*n;

return(f);

}

扩展资料：return用法：

return返回一个数值的意思就是把return

后面表达式的值返回给调用他的函数。举个例子：

int sum(int i,int j)

{

return i+j;

printf("这个语句不会被执行，因为该子函数执行到上面的return语句就无条件结束了");

}

main()

{

int a=10,b=11,c;

c=sum(a,b);

printf("%d",c);

}

程序的输出为：

21

这个21从何而来呢main函数调用sum(a,b)函数时将a的值赋给i，b的值赋给j，上面说了return i+j;会计算i＋j的值也就是结果等于21，并将21带回给调用它的函数，即c=sum(a,b);相当于c=21，这个21就是由sum（a,b)中的return反回来的。

C语言怎么用递归法求阶乘

没错按道理来说是 不满足 条件 (n>1) 时才执行 return 1;
加上 else 程序看起来更清楚。
可是 因为 满足 条件 (n>1) 时执行的是
return (n*fun(n-1));
就已经退出函数了
所以 else 就可以省略了，只有 不满足 条件 (n>1) 时才会执行到 return 1;
思路分析：
n! = n*(n-1)! // n的阶乘可以化为n乘以(n-1) 的阶乘，这就是递归
当n=0或1时，n! = 1 // 这就是递归终止条件
实现算法程序：
double fun(int n) // 递归函数求n的阶乘{ if(n==0 || n==1) // 递归终止条件 return 1; else return n*fun(n-1); // 进行递归运算}
1、首先打开vc6.0，新建一个vc项目。
2、接下来需要添加头文件。
3、添加main主函数。
4、定义一个用来求阶乘的函数。
5、在main函数定义int类型变量sum。
6、调用fact()，并将返回值赋予sum。
7、使用printf打印sum。
8、运行程序，看看结果。

编写用C语言实现的求n阶阶乘问题的递归算法

　　代码如下：
　　long int fact(int n)
　　{
　　int x;
　　long int y;
　　if(n<0)
　　{
　　printf(“error!”);
　　}
　　if(n==0)
　　return 1;
　　x=n-1;
　　y=fact(x);
　　return (n*y);
　　}
　　拓展阅读：
　　特点
　　递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
　　递归算法解决问题的特点：
　　(1) 递归就是在过程或函数里调用自身。
　　(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
　　(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
　　(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。
　　要求
　　递归算法所体现的“重复”一般有三个要求：
　　一是每次调用在规模上都有所缩小(通常是减半);
　　二是相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入);
　　三是在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

用C语言求N的阶层。程序怎么写

再补充：已经改善为完整版本
补充：我的回答为递推算法，有一位的算法为递归算法。递推比递归快得多，而且需求内存也更小、程序也更精炼。
#include

using namespace std;

void main()

{

long N;

cin>>N;

if(N<0)

{

cout<"Invalid input."<
<endl;
unsigned long result=1;

/*使用unsigned为使能够求更大的。其实也可以用long double，虽然是实型，没有关系。*/

for(long i=1;i<=N;i++)

{

result*=i;

}

cout<
<result<<endl;
}

result就是N的阶乘。

#include

main()

{

long n,i,sq=1;

scanf("%d",&n); //输入N的值

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

sq=sq*i;

printf("%d",sq);

} //呵呵结束，我觉得这些小程序不需要C++，C语言足以

#include

void main()

{ unsigned int i,j;

scanf("%d",&j);

for(i=1,i
<j,i++) j*="i;
printf("%d",j);

}

最后输出的j就是j的阶乘.换成N一样.

我也是刚学完C语言不久,要是对了,请鼓励下!

我说一下，对于这样的定义，无论long还是unsinged long

都计算的有限。对于较大的数，我们不要求太精确所以，用科学计数法来表示，就可以扩大计算范围了。

#include

double Fac(double n)

{

return n > 1 ? n * Fac(n-1) : 1;

}

int main()

{

printf("%.lf", Fac(4));

}

1、使用递归算法

#include

#include

long factorial(int n){ long result; if (n<0) { printf("n<0,请输入大于等于0的整数!"); return -1; } else if (n == 0 || n == 1) { result = 1; } else { result = n*factorial(n - 1); } return result;}main(){ int n = 10.0; long iNum; iNum = factorial(n); printf("10!=%ld\n", iNum); system("pause");}2、使用循环

#include

#include

int main(){ int i = 1; //累加变量 long j = 1; //储存结果 int k = 1; //输入的数值 printf("请输入一个数字:"); scanf("%d", &k); do { j = j*i; i++; } while (i <= k); printf("%ld\n", j); system("pause"); return 1;}以上两种方式是求阶乘的普通算法，求得的结果表示范围都是有限的，如果算大数的阶乘还要另外的算法。

</result<<endl;
</endl;

在java中，用递归方法计算n的阶乘。

关键代码:public int fac(int n){ int f; if(n==0 || n==1) f=1; else f=n*fac(n-1);return f;}
public class fab{public static int f(int n ){ if(n==1){return 1;}else{return n*f(n-1);}}public static void main(String[] args){system.out.println(f(5));}}
用Java求键盘输入的数的阶乘n。（递归算法）packagejiecheng; importjava.util.*; //导入java.util包中的所有类classrep{ publiclongrep(intn){ longi=0; if(n==0||n==1) i=1;
elsi=n*rep(n-1) returni; } } publicclassJie { publicstaticvoidmain(String[] args) { intn; //此处定义要输入的数Scanner s = newScanner(System.in); //以下三行用于n的值得输入System.out.print( "请输入一个整数："); n = s.nextInt(); rep f= newrep(); System.out.println(n+"!="+f.rep(n)); } }
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
发展历程：20世纪90年代，硬件领域出现了单片式计算机系统，这种价格低廉的系统一出现就立即引起了自动控制领域人员的注意，因为使用它可以大幅度提升消费类电子产品（如电视机顶盒、面包烤箱、移动电话等）的智能化程度。
Sun公司为了抢占市场先机，在1991年成立了一个称为Green的项目小组，帕特里克、詹姆斯·高斯林、麦克·舍林丹和其他几个工程师一起组成的工作小组在加利福尼亚州门洛帕克市沙丘路的一个小工作室里面研究开发新技术，专攻计算机在家电产品上的嵌入式应用。