递归函数c语言求n的阶乘,C语言用函数思想求n的阶乘

递归函数c语言求n的阶乘,C语言用函数思想求n的阶乘详细介绍

本文目录一览： 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语言怎么用递归法求阶乘

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语言递归求阶乘

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

#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) 时才执行 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的阶乘的程序代码

int f(int n)
{
if(n==1)
return 1;
else
return n*f(n-1);
}
这个是经典的迭代程序例子。
#include

main()

{

int n,i,j=1,sum=0;

printf("请输入n的值：\n");

scanf("%d",&n);

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

{

j=j*i;

}

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

}

电脑验证过，放心用吧！

main()

{int n;cout<<"输入要求的阶乘：";

cin>>n;

for(int i=n;n>=1;n--)

long int M=1;

M*=n;

cout<
<n<<"的阶乘为："<<m<<endl;
}

#include

void main()

{

int i,n,temp=1;

scanf("%d",&n);

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

{

temp=temp*i;

}

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

}

这个简单 哥们我来。

void main{

int n;//n的数

int i;//计数用

int product=1;//做乘之和

scanf("%d",&n);

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

product=product*i;

printf("the product from 1 to %d",n);

}

用递归法求N的阶乘

程序调用自身称为递归（ recursion）.它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解.

递归的能力在于用有限的语句来定义对象的无限集合。

一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

#include

#include

#include

long factorial(int n)

{

if(n == 1)

return 1;

else

return n*factorial(n-1);

}

int main(int argc,char *argv[])

{

int n = 0;

if(argc != 2)

{

printf("input error,exit!!\n");

return -1;

}

n = atoi(argv[1]);

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

return 0;

}

习题示例

题目

题目描述：

输入一个正整数N，输出N的阶乘。

输入：

正整数N(0<=N<=1000)

输出：

输入可能包括多组数据，对于每一组输入数据，输出N的阶乘

样例输入：

4

5

15

样例输出：

24

120

1380000

AC代码

#include

#include

#include

#define MAX 3000

//存储每次阶乘运算的结果

int str[MAX];

void calculateFactorial(int n);

int main()

{

int n;

while (scanf("%d", &n) != EOF) {

if(n == 0) {

printf("1\n");

} else {

calculateFactorial(n);

}

}

return 0;

}

void calculateFactorial(int n)

{

int i, j, temp, c, len;

memset(str, 0, sizeof(str));

str[1] = 1;

for (i = 2, len = 1; i <= n; i ++) { //循环与2,3,..n相乘

for (j = 1, c = 0; j <= len; j ++) { //str数组代表一个数，模拟与i相乘

temp = str[j] * i + c;

str[j] = temp % 10;

c = temp / 10;

}

while(c > 0)

{

str[j ++] = c % 10;

c /= 10;

}

len = j - 1;

}

for (i = len; i >= 1; i --) {

printf("%d", str[i]);

}

printf("\n");

}

/**************************************************************

Problem: 1076

User: wangzhengyi

Language: C

Result: Accepted

Time:2150 ms

Memory:916 kb

</n<<"的阶乘为："<<m<<endl;

c语言用递归法计算n

long ff(int n) //函数作用是计算N的阶乘 { long f; if(n<0)printf("n<0,input error");//n不能为负数 else if(n==0||n==1)f=1;//这里使ff(0)和ff(1）等于1 else f=ff(n-1)*n;//这里使ff(n) = n * ff(n-1),重要,因为当形参n = n-1时，ff(n-1) = ff(n-2) * （n-1)，所以这一步实际实现了n阶乘计算，即ff(n) = n * ff(n-1) = n * (n-1) * ff(n-2).....*ff(1) *ff(0)，因为ff(0) == ff(1) == 1.所以ff(n) = n!实现。 return(f);}

c语言编程：用递归实现计算n!。

#include

float face(int n)

{

float f;

if(n<0)

printf("n<0, dataerror!");

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

f=1;

else

f=face(n-1)*n;

return(f);

}

main()

{

int n;

float y;

printf("input a integer number:");

scanf("%d",&n);

y=face(n);

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

}

绝对正确

这样子写程序就可以了，vc6下验证成功

#include

void main()

{

long int sum=0;

long int count(int n);

int n;

printf("input n=");

scanf("%d",&n);

printf("result is %ld\n",count(n));

}

long int count(int n)

{

if(n>1)

return n*count(n-1);

else

return 1;

}

算递归最好用double类型，否则很容易溢出。

#include

double fact(double x)

{

if(x==0)

return 1;

else

return fact(x-1) * x;

}

int main()

{

int x;

scanf("%d", &x);

printf("%f", fact(x));

return 0;

}

输入n>=0，则返回n！，否则返回-1

#include

void main()

{

long int sum=0;

long int count(int n);

int n;

printf("input n=");

scanf("%d",&n);

printf("result is %ld\n",count(n));

}

long int count(int n)

{

if(n>1)

return n*count(n-1);

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

return 1;

else

return -1;

}

由于对于任意的n，

n! = (n-1)! * n;

即令f(n) = n!,存在公式

f(n) = f(n-1) * n;

在这个递归公式下，编写递归求阶乘代码如下：

int fac(int n){ if(n == 0 || n == 1) return 1; return fac(n-1)*n;}