递归函数c语言阶乘,C语言怎么用递归法求阶乘

递归函数c语言阶乘,C语言怎么用递归法求阶乘详细介绍

本文目录一览： c语言怎么用递归调用函数的方法求n的阶乘？

unsigned int Jiechen(unsigned int n)
{
if(n==0) return 1; /* 0 的阶乘等于 1, 直接返回 1 */
else return n * jiechen(n-1); /* 否则 n! = n * (n-1)! 此处是递归调用函数 Jiechen() */
}
C语言，是一种通用的、过程式的编程语言，广泛用于系统与应用软件的开发。具有高效、灵活、功能丰富、表达力强和较高的移植性等特点，在程序员中备受青睐。最近25年是使用最为广泛的编程语言。
C语言是由UNIX的研制者丹尼斯·里奇（Dennis Ritchie）于1970年 由 肯·汤普逊（Ken Thompson）所研制出的B语言的基础上发展和完善起来的。目前，C语言编译器普遍存在于各种不同的操作系统中，例如UNIX、MS-DOS、Microsoft Windows及Linux等。C语言的设计影响了许多后来的编程语言，例如C++、Objective-C、Java、C#等。
解决步骤：
#include

long fun(int n)

{

if (n>1)

return (n*fun(n-1));

return 1;/*我的疑问在这里，难道不应该是else return 1吗？根据答案提示这里的1可以换成1L，是什么道理？*/

}

main()

{

printf("10!=%ld\n", fun(10));

}

语言标准

起初，C语言没有官方标准。1978年由美国电话电报公司(AT&T）贝尔实验室正式发表了C语言。布莱恩·柯林汉（Brian Kernighan） 和 丹尼斯·里奇（Dennis Ritchie） 出版了一本书，名叫《The C Programming Language》。这本书被 C语言开发者们称为K&R，很多年来被当作 C语言的非正式的标准说明。人们称这个版本的 C语言为K&R C。 [3]

K&R C主要介绍了以下特色：

结构体（struct）类型

长整数（long int）类型

无符号整数（unsigned int）类型

把运算符=+和=-改为+=和-=。因为=+和=-会使得编译器不知道使用者要处理i = -10还是i =- 10，使得处理上产生混淆。

即使在后来ANSI C标准被提出的许多年后，K&R C仍然是许多编译器的最 准要求，许多老旧的编译器仍然运行K&R C的标准。

1970到80年代，C语言被广泛应用，从大型主机到小型微机，也衍生了C语言的很多不同版本。

1983年，美国国家标准协会（ANSI）成立了一个委员会X3J11，来制定 C语言标准。 [4]

1989年，美国国家标准协会（ANSI）通过了C语言标准，被称为ANSI X3.159-1989 "Programming Language C"。因为这个标准是1989年通过的，所以一般简称C89标准。有些人也简称ANSI C，因为这个标准是美国国家标准协会（ANSI）发布的。

1990年，国际标准化组织（ISO）和国际电工委员会（IEC）把C89标准定为C语言的国际标准，命名为ISO/IEC 9899:1990 - Programming languages -- C [5] 。因为此标准是在1990年发布的，所以有些人把简称作C90标准。不过大多数人依然称之为C89标准，因为此标准与ANSI C89标准完全等同。

1994年，国际标准化组织（ISO）和国际电工委员会（IEC）发布了C89标准修订版，名叫ISO/IEC 9899:1990/Cor 1:1994[6] ，有些人简称为C94标准。

1995年，国际标准化组织（ISO）和国际电工委员会（IEC）再次发布了C89标准修订版，名叫ISO/IEC 9899:1990/Amd 1:1995 - C Integrity [7] ，有些人简称为C95标准。

C99标准

1999年1月，国际标准化组织（ISO）和国际电工委员会（IEC）发布了C语言的新标准，名叫ISO/IEC 9899:1999 - Programming languages -- C [8] ，简称C99标准。这是C语言的第二个官方标准。

在C99中包括的特性有：

增加了对编译器的限制，比如源程序每行要求至少支持到 4095 字节，变量名函数名的要求支持到 63 字节（extern 要求支持到 31）。

增强了预处理功能。例如：

宏支持取可变参数 #define Macro(...) __VA_ARGS__

使用宏的时候，允许省略参数，被省略的参数会被扩展成空串。

支持 // 开头的单行注释（这个特性实际上在C89的很多编译器上已经被支持了）

增加了新关键字 restrict, inline, _Complex, _Imaginary, _Bool

支持 long long, long double _Complex, float _Complex 等类型

支持不定长的数组，即数组长度可以在运行时决定，比如利用变量作为数组长度。声明时使用 int a[var] 的形式。不过考虑到效率和实现，不定长数组不能用在全局，或 struct 与 union 里。

变量声明不必放在语句块的开头，for 语句提倡写成 for(int i=0;i<100;++i) 的形式，即i 只在 for 语句块内部有效。

允许采用（type_name）{xx,xx,xx} 类似于 C++ 的构造函数的形式构造匿名的结构体。

复合字面量：初始化结构的时候允许对特定的元素赋值，形式为：

struct test{int a[3]，b;} foo[] = { [0].a = {1}, [1].a = 2 };

struct test{int a, b, c, d;} foo = { .a = 1, .c = 3, 4, .b = 5 }; // 3,4 是对 .c,.d 赋值的

格式化字符串中，利用 \u 支持 unicode 的字符。

支持 16 进制的浮点数的描述。

printf scanf 的格式化串增加了对 long long int 类型的支持。

浮点数的内部数据描述支持了新标准，可以使用 #pragma 编译器指令指定。

除了已有的 __line__ __file__ 以外，增加了 __func__ 得到当前的函数名。

允许编译器化简非常数的表达式。

修改了 /% 处理负数时的定义，这样可以给出明确的结果，例如在C89中-22 / 7 = -3, -22% 7 = -1，也可以-22 / 7= -4, -22% 7 = 6。 而C99中明确为 -22 / 7 = -3, -22% 7 = -1，只有一种结果。

取消了函数返回类型默认为 int 的规定。

允许 struct 定义的最后一个数组不指定其长度，写做 [](flexible array member)。

const const int i 将被当作 const int i 处理。

增加和修改了一些标准头文件，比如定义 bool 的

，定义一些标准长度的 int 的

，定义复数的

，定义宽字符的

，类似于泛型的数学函数

， 浮点数相关的

。 在

增加了 va_copy 用于复制 ... 的参数。里增加了 struct tmx ，对 struct tm 做了扩展。

输入输出对宽字符以及长整数等做了相应的支持。

GCC和其它一些商业编译器支持C99的大部分特性。

C11标准

2011年12月8日，国际标准化组织（ISO）和国际电工委员会（IEC）再次发布了C语言的新标准，名叫ISO/IEC 9899:2011 - Information technology -- Programming languages -- C [9] ，简称C11标准，原名C1X。这是C语言的第三个官方标准，也是C语言的最新标准。

新的标准提高了对C++的兼容性，并增加了一些新的特性。这些新特性包括：

对齐处理(Alignment)的标准化(包括_Alignas标志符，alignof运算符, aligned_alloc函数以及

头文件。

_Noreturn 函数标记，类似于 gcc 的 __attribute__((noreturn))。

_Generic 关键字。

多线程(Multithreading)支持，包括：

_Thread_local存储类型标识符，

头文件，里面包含了线程的创建和管理函数。

_Atomic类型修饰符和

头文件。

增强的Unicode的支持。基于C Unicode技术报告ISO/IEC TR 19769:2004，增强了对Unicode的支持。包括为UTF-16/UTF-32编码增加了char16_t和char32_t数据类型，提供了包含unicode字符串转换函数的头文件

.

删除了 gets() 函数，使用一个新的更安全的函数gets_s()替代。

增加了边界检查函数接口，定义了新的安全的函数，例如 fopen_s()，strcat_s() 等等。

增加了更多浮点处理宏。

匿名结构体/联合体支持。这个在gcc早已存在，C11将其引入标准。

静态断言(static assertions)，_Static_assert()，在解释 #if 和 #error 之后被处理。

新的 fopen() 模式，(“…x”)。类似 POSIX 中的 O_CREAT|O_EXCL，在文件锁中比较常用。

新增 quick_exit() 函数作为第三种终止程序的方式。当 exit()失败时可以做最少的清理工作。

1、打开VC6.0软件，新建一个C语言的项目：

2、接下来编写主程序，首先定义用来求阶乘的递归函数以及主函数。在main函数里定义变量sum求和，调用递归函数fact()，并将返回值赋予sum，最后使用printf打印sum的结果，主程序就编写完了：

3、最后运行程序，观察输出的结果。以上就是C语言使用递归求阶乘的写法：

编写用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

int fac(int n)

{

if(n < 0)

{

printf("error!\n");

return -1;

}

else if(n == 0)

return 1;

else

return fac(n- 1) * n;;

}

void main()

{

int n = 0;

printf("请输入n:");

scanf(%d",&n);

printf("%d的阶乘是%d",n,fac(n));

}

随手写的，没有编译，可能有小错误

int fn(n)

{

int y;

if(n<0)｛ printf("error");return -1;}

if(n==0) return 1;

else

{

y=fn(n-1)

return n*y;

}

}

思路：递归求阶乘函数，如果输入的参数等于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;}/*5120*/

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));
}

c语言问题，求1-35的阶乘！！！！

数有点大，会溢出出错，
可以改成double型数据试试
#include

void main (void)

{

double a=1;

int i;

for (i=1;i<=35;a=a*(double)i)

{printf ("%d!=%lf\n",i,a);

i++;

}

}

首先不管你的程序对不对int型的数据存储35的阶乘基本上来说肯定溢出所以你的数据类型定义的就有问题

计算结果超出int所能表示的范围了！

C语言的int类型与开发环境平台有关，可能是16位（2^16）,也可能是32位（2^32）,估计现在大多数开发环境都是用32位的，可达到4294967296，相当于long int。但你的程序计算结果却大于这个数，因此无法显示。

解决办法：

可以把计算结果不用整形表示，用double长浮点数，计算结果中不保留小数点后面的位数就行了，改成如下，已经试验通过。

#include

void main (void)

{

double a=1;

int i;

for (i=1;i<=35;a=a*i)

{printf ("%d!=%.lf\n",i,a);

i++;

}

}

会溢出、double a；就好了

1、首先在电脑中打开C语言软件，定义一个函数，并传入一个参数。

2、然后定义一个result变量，如下图所示。

3、接着当传入的参数为1的时候，值为1，如下图所示。

4、而传入的参数不是1的时候，使用递归函数来计算阶乘，jiecheng(n-1)*n，如下图所示。

5、返回结果result，在主函数里面调用这个阶乘函数。

6、最后编译运行这个函数，如下图所示就完成了。

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的阶乘

#include

// 声明递归函数 factorial，用于计算 n 的阶乘

int factorial(int n);

int main() {

int n;

printf("请输入一个非负整数 n: ");

scanf("%d", &n);

if (n < 0) {

printf("输入错误！\n");

return -1;

}

printf("%d 的阶乘为 %d\n", n, factorial(n));

return 0;

}

// 定义递归函数 factorial，用于计算 n 的阶乘

int factorial(int n) {

if (n == 0 || n == 1) { // 边界条件

return 1;

} else {

return n * factorial(n-1); // 递归调用

}

}

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!m!(n-m)! 用递归函数求，帮我看看哪错了？

scanf少个%d吧
不需要这么多函数。。。直接一个求阶乘的就行。
#include
int
fun(int
a)
{
int
f;
if
(a==1||a==0)
f=1;
else
f=a*fun(a-1);
return
f;
}
void
main()
{
int
n,m;
float
x;
printf("输入2个数：\n");
scanf("%d%d",&n,%m);
x=fun(n)/fun(m)*fun(n-m);
printf("结果是：%f\n",x);
}
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));
}

c语言c语言c语言中的阶乘怎么算

递归+高精度就可以
Cnk = [ n (n-1)(n-2)....(n-k+1) ] / k的阶乘；
例如：C5 2 =（5×4 ）÷ （ 2×1）=10。
对于任意一个n次多项式，总可以只借助最高次项和（n-1）次项，根据二项式定理，凑出完全n次方项，其结果除了完全n次方项，后面既可以有常数项，也可以有一次项、二次项、三次项等，直到（n-2）次项。
特别地，对于三次多项式，配立方，其结果除了完全立方项，后面既可以有常数项，也可以有一次项。
扩展资料：
由于二次以上的多项式，在配n次方之后，并不能总保证在完全n次方项之后仅有常数项。于是，对于二次以上的一元整式方程，无法简单地像一元二次方程那样，只需配出关于x的完全平方式，然后将后面仅剩的常数项移到等号另一侧，再开平方，就可以推出通用的求根公式。
对于求解二次以上的一元整式方程，往往需要大量的巧妙的变换，无论是求解过程，还是求根公式，其复杂程度都要比一次、二次方程高出很多。