#include
long fun(int n)
{
if(n>1)
return(n*fun(n-1));
return 1;
}
main()
{
printf("5!=%ldn",fun(5));
}
递归10：
#include
long fun(int n)
{
if(n>1)
return(n*fun(n-1));
return 1;
}
main()
{
printf("10!=%ldn",fun(10));
}它的原理就是反推，如，举例，求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乘阶值，
原理就是，执行 long fun(int n)
{
if(n>10)
{
return (n*fun(n-1)) 此时执行这fun(n-1)实际上是把n减1，从新调用fun，n-1做为一个fun()形式参数，在执行fun函数，并且在回一个值，在一个新形式参数,在执行fun函数,并且在回一个值,注意 直到n-1=1,为一个实际参数,所以if>1,n-1=1,求得一个实际参数，执行到第9次，fun(n*(n-1))//n-1为一个实际参数1，n为2，n！=n*(n-1)！n-1=1,
2!=2,第9次n-1，执行完后因并没有执行第10次fun()函数所以n=2；在公式往上推，执行顺序为
if(n>1)
{
return
{(n*fun(n-1)) n=10 n-1=9 1次执行
if(n>1)
return (n*fun(n-1)) 2次执行 n=9n-1=8
if(n>1)
return (n*fun(n-1)) 3次执行 n=8 n-1=7
if(n>1)
return (n*fun(n-1)) 4次执行 n=7 n-1=6
if(n>1)
return (n*fun(n-1)) 5次执行 n=6 n-1=5
if(n>1)
return (n*fun(n-1)) 6次执行 n=5 n-1=4
if(n>1)
return (n*fun(n-1)) 7次执行n=4 n-1=3
if(n>1)
return (n*fun(n-1)) 8次执行n=3 n-1=2
if(n>1) 9次执行 n=2 n-1=1
return (n*fun(n-1))
//第9回 n-1为实际参数，所以从第9回开始算起，往回公式推而第一次执行fun函数一直调用8fun(n-1)) ，才停，因为n>1 ,科学家规定0！=1 所以0！=1！设置成n>1,后执行9次n-1,
n=2,求2的! 2!=2*(n-1)！ 而此n-1=1为实际参数，它的阶乘为它本身，
2！=2*1;可以求出2的! 在往回推,就可以了,
快三三期必中口诀执行了9次，n-1=1 ，n=2已经调用就可以求2乘阶值，原理就是，执行 long fun(int n)
{
if(n>10)
{
return (n*fun(n-1)) 此时执行这fun(n-1)实际上是把n减1，从新调用fun，n-1做为一个fun()形式参数，在执行fun函数，并且在回一个值，在一个新形式参数,在执行fun函数,并且在回一个值,注意 直到n-1=1,为一个实际参数,所以if>1,n-1=1,求得一个实际参数，执行到第9次，fun(n*(n-1))//n-1为一个实际参数1，n为2，n！=n*(n-1)！n-1=1,
2!=2,第9次n-1，执行完后因并没有执行第10次fun()函数所以n=2；在公式往上推，执行顺序为
if(n>1)
{
return
{(n*fun(n-1)) n=10 n-1=9 1次执行
if(n>1)
return (n*fun(n-1)) 2次执行 n=9n-1=8
if(n>1)
return (n*fun(n-1)) 3次执行 n=8 n-1=7
if(n>1)
return (n*fun(n-1)) 4次执行 n=7 n-1=6
if(n>1)
return (n*fun(n-1)) 5次执行 n=6 n-1=5
if(n>1)
return (n*fun(n-1)) 6次执行 n=5 n-1=4
if(n>1)
return (n*fun(n-1)) 7次执行n=4 n-1=3
if(n>1)
return (n*fun(n-1)) 8次执行n=3 n-1=2
if(n>1) 9次执行 n=2 n-1=1
return (n*fun(n-1))
//第9回 n-1为实际参数，所以从第9回开始算起，往回公式推而第一次执行fun函数一直调用8fun(n-1)) ，才停，因为n>1 ,科学家规定0！=1 所以0！=1！设置成n>1,后执行9次n-1,
n=2,求2的! 2!=2*(n-1)！ 而此n-1=1为实际参数，它的阶乘为它本身，
2！=2*1;可以求出2的! 在往回推,就可以了,