递归调用(C语言)
C语言用递归方法求n阶勒让德多项式的值
C语言用递归方法求n阶勒让德多项式的值勒让德多项式（Legendre Polynomial）是一类重要的正交多项式，经常在物理和数学中出现。
在数值计算中，常常需要计算n阶勒让德多项式的值。
下面将介绍使用递归方法求解n阶勒让德多项式的值。
首先，我们需要了解勒让德多项式的递归定义。
n阶勒让德多项式Pn(x)可以通过以下递推关系定义：P0(x)=1P1(x)=xPn(x)=((2n-1)xPn-1(x)-(n-1)Pn-2(x))/n其中P0(x)和P1(x)为已知的初始条件。
根据递推关系，我们可以通过计算前面两项的值来递归地计算出Pn(x)的值。
接下来，我们将使用C语言来实现这个递归函数。
首先，我们定义一个函数`legendre(int n, double x)`，该函数接受n和x作为参数，并返回n阶勒让德多项式在x处的值。
```c#include <stdio.h>double legendre(int n, double x)//初始条件if (n == 0)return 1;else if (n == 1)return x;//递归计算return ((2 * n - 1) * x * legendre(n - 1, x) - (n - 1) * legendre(n - 2, x)) / n;int mainint n;double x;printf("请输入n的值：");scanf("%d", &n);printf("请输入x的值：");scanf("%lf", &x);double result = legendre(n, x);printf("n阶勒让德多项式的值为：%lf\n", result);return 0;```在主函数中，首先从用户输入中获取n和x的值，然后调用`legendre`函数计算n阶勒让德多项式在x处的值，最后输出结果。
c语言递归调用求阶乘
c语言递归调用求阶乘C语言中的递归调用是一种非常有用的编程技术，可以用来解决许多数学和计算问题。
其中，求阶乘是一个经典的例子，可以很好地展示递归调用的原理和应用。
首先，让我们来看一下阶乘的定义，n的阶乘（记作n!）是指从1到n的所有正整数相乘的结果。
例如，5的阶乘是12345=120。
在C语言中，可以使用递归调用来计算阶乘。
递归是指一个函数调用自身的过程，这种方法在计算阶乘时非常有效。
下面是一个使用递归调用来计算阶乘的C语言函数的示例：c.#include <stdio.h>。
int factorial(int n) {。
if (n == 0 || n == 1) {。
return 1;} else {。
return n factorial(n 1);}。
}。
int main() {。
int num = 5;int result = factorial(num);printf("The factorial of %d is %d\n", num, result); return 0;}。
在上面的代码中，factorial函数使用递归调用来计算阶乘。
当n为0或1时，返回1；否则，返回n乘以factorial(n-1)的结果。
在main函数中，我们调用了factorial函数来计算5的阶乘，并打印出结果。
递归调用求阶乘的过程可以用一棵树来表示，每个节点表示一个函数调用，树的叶子节点表示递归的结束条件。
通过递归调用，我们可以很方便地实现对阶乘的计算，而且代码也更加简洁和易于理解。
当然，递归调用也有一些缺点，比如可能会消耗更多的内存和时间。
在实际应用中，需要根据具体情况来选择是否使用递归调用来解决问题。
总之，递归调用是C语言中一种非常有用的编程技术，可以用来解决各种计算问题，包括求阶乘。
通过递归调用，我们可以更加简洁地表达问题的解决方法，同时也能更好地理解问题的本质。
c语言中递归调用的教学设计
c语言中递归调用的教学设计
一、教学目标
1、学生能够理解递归调用的概念并能够熟练应用；
2、学生能够熟练使用C语言来编写递归调用函数；
3、学生能够熟练分析递归函数的作用和特点。
二、教学步骤
教学过程：
1、教师介绍递归调用的概念：递归调用是指函数自身有调用函数自身的能力；
2、教师引导学生复习编写简单的C语言程序的流程；
3、教师展示如何在C语言程序中编写递归调用函数；
4、学生完成基于给定的函数原型的代码编写任务；
（students should be asked to investigate the properties of a recursive function , derive recursive functions for specific tasks and give general
recursive solutions for problems）
5、教师进一步分析递归函数的结构及其作用特点，着重强调递归函
数的数据缓存，时间复杂度计算等概念；
6、进行练习，让学生尝试在C语言程序中编写相应的函数等；
7、最后，教师总结学习内容，布置作业重点练习相关内容。
三、教学反思
1、通过教学，让学生了解递归调用的概念及应用；
2、通过教学，让学生充分理解和利用递归调用函数的特点；
3、进一步完善教学，丰富学员的数据处理能力，完善参与学习的环境；
4、完善和升华学习成果体现，并督促学习者在实践中进一步加深理解。
c语言猴子吃桃问题递归法
c语言猴子吃桃问题递归法
"猴子吃桃"问题是一个经典的递归问题。
故事是这样的：猴子摘下了n个桃子，
第一天吃掉了桃子数的一半又多吃了一个，接下来的每一天也是吃前一天剩下的
一半再多吃一个，到了第m天就剩下一个桃子了。
下面是用C语言和递归方法
来解决这个问题。
```c
#include
<stdio.h>
int total_peaches(int n, int day) {
if (day == 1) {
return1; // 最后一天剩下一个桃子
} else {
return (total_peaches(n, day - 1) + 1) * 2; // 第二天桃子数是前一天加1后的两倍
}
}
int main() {
int n = 100; // 初始的桃子数
int day = 9; // 经过的天数，可以根据需要更改
printf("总共摘了 %d 个桃子\n", total_peaches(n, day));
return0;
}
这个程序会计算出猴子在经过指定的天数后总共摘了多少个桃子。
注意，递归的
终止条件是当只剩下一个桃子的时候，此时的天数（我们这里设定为1）。
在每
一天，桃子的数量是前一天加1后的两倍。
C语言的函数递归探析
C语言的函数递归探析摘要：函数递归其有逻辑性强、结构层次清晰，可以用数学归纳法得出正确结论的优点。
对C语言的函数递归进行了论述。
关键词：C语言；函数递归；程序1 函数递归所谓函数递归，是指在一个函数中有直接或间接调用函数本身。
函数直接递归指函数直接在本函数中调用自身。
函数间接递归指本函数调用其它函数，其它函数又调用本函数。
直接递归和间接递归图解如图1所示。
如图1所示，递归调用可以说是一种函数循环，程序中循环必须有中止条件，否则就会陷入死循环。
所以，递归调用必须有中止条件，只有递归条件满足时才调用自身，否则（即满足中止条件），函数就不再递归调用。
C语言中函数递归有独特的作用。
很多时候，巧用函数递归可以解决许多看似复杂难解的问题。
2 函数递归特征那么什么时候函数可以用递归方法呢？递归函数有何特征？本文总结了3条规则：①函数中所需要计算的数值可以通过调用自身得到，所以递归函数必须有返回值;②函数参数值往往是有规律地递增或递减;③必须有中止条件，一般以限定函数参数值或递归函数返回值为中止条件。
让我们先分析一下简单的递归函数：n!n!的数学表达式为：n!=n*(n-1)*(n-2)*……*2*1当n=1时，值为1当n>1时，n!=n*(n-1)!这个数学表达式能够满足3条规则，求n!的函数值为n乘以(n-1)!的函数值，函数参数只要递减1设置即可，另外设置中止返回值为1，即最后一个函数的值为1(因为1!=1)。
该递归函数如下：int f2(int n){if(n<1) return 0;else if(n= =1) return 1;elsereturn n*f(n-1);}这个问题很简单明了，不再作深入分析。
再看另外一题：求∑n!此题的数学表达式为1!+2!+ ……+(n-1)!+n!上题已经得知n!可以通过递归函数得解。
而这个函数看上去也有相似规律可循。
设求此题的函数为f1(n);则当n=1时，f1(1)=1n=2时，f1(2)=1!+2!=f2(1)+f2(2)=f1(1)+f2(2)n=3时，f1(3)=1!+2!+3!=f1(2)+f2(3)……n=n时，f1(n)=f1(n-1)+f2(n)显然f1(n)需要得到的数值包含f1(n-1)，且函数参为规律的递减，函数中止条件设返回值为1。
c语言 函数递归调用 conflicting types -回复
c语言函数递归调用conflicting types -回复C语言函数递归调用中的"conflicting types"错误是指在使用函数递归调用时，函数的声明与定义之间存在冲突。
这个错误通常发生在编译阶段，是由于函数声明和定义之间的参数类型、返回类型或函数名不匹配所造成的。
在本文中，我们将一步一步回答有关这个错误的问题，并提供解决方案以帮助理解这个问题。
一、什么是函数递归调用？在介绍"conflicting types"错误之前，让我们首先了解函数递归调用的概念。
函数递归调用是指函数在其自身内部调用自身的过程。
通过这种递归调用，函数可以解决一些需要多次迭代的问题，因为每次调用函数时，它会自己再次调用自身，直到满足某个终止条件。
二、为什么会出现"conflicting types"错误？现在让我们来探讨"conflicting types"错误的原因。
这个错误通常发生在函数的声明和定义之间发生不匹配的情况下，包括以下几种情况：1. 函数参数类型不匹配：函数的声明和定义之间的参数类型不一致。
这可能是由于函数声明时没有提供正确的参数类型，或者参数类型的顺序不正确。
2. 函数返回类型不匹配：函数的声明和定义之间的返回类型不匹配。
这可能是由于函数声明时没有提供正确的返回类型，或者返回类型与函数定义中的不匹配。
3. 函数名不匹配：函数的声明和定义之间的函数名不相同。
这可能是由于函数声明时拼写错误或者函数名的大小写不同。
三、如何修复"conflicting types"错误？现在我们来看一些常见的解决方案，以帮助您修复"conflicting types"错误：1. 检查函数声明和定义：首先，确保函数的声明和定义之间的参数类型、返回类型和函数名都是一致的。
检查声明和定义之间的差异，并对其进行修复。
c语言函数递归调用
c语言函数递归调用C语言函数递归调用在C语言中，函数递归调用是一种函数自身调用自身的技术。
通过递归调用，可以解决一些需要重复执行的问题，简化代码逻辑，提高程序的可读性和可维护性。
本文将介绍C语言函数递归调用的基本原理、使用方法以及注意事项。
一、递归调用的原理函数递归调用是基于函数的自身调用，即函数内部直接或间接地调用自己。
当函数执行到递归调用语句时，会暂时中断当前的执行，转而执行被调用的函数，直到满足某个条件才会停止递归，然后逐层返回，继续执行未完成的代码。
二、递归调用的语法在C语言中，通过在函数体内部调用函数本身来实现递归调用。
递归函数通常包含两部分：递归终止条件和递归调用语句。
递归终止条件用于判断是否需要继续递归调用。
当满足终止条件时，递归调用将停止，函数开始逐层返回。
如果没有设置递归终止条件或者终止条件不满足，递归将无限进行下去，导致堆栈溢出。
递归调用语句是实际进行递归的部分。
通过在函数体内部调用函数本身，可以将问题不断地分解为更小的子问题，直到问题被分解为最简单的情况，然后逐层返回结果，最终得到问题的解。
三、递归调用的使用场景函数递归调用在解决一些需要重复执行的问题时非常有用。
以下是一些常见的使用场景：1. 阶乘计算：通过递归调用，可以很方便地计算一个数的阶乘。
例如，计算n的阶乘可以定义一个递归函数factorial(n)，其中终止条件是n为1，递归调用语句是return n * factorial(n - 1)。
2. 斐波那契数列：递归调用可以简洁地实现斐波那契数列的计算。
斐波那契数列的定义是前两个数为1，之后的数是前两个数的和。
通过递归调用，可以轻松计算出斐波那契数列的第n个数。
3. 文件路径遍历：在文件系统中，递归调用可以用于遍历文件路径，实现深度优先搜索。
通过递归调用，在遍历一个目录下的所有文件和子目录时，可以方便地遍历子目录中的文件。
四、递归调用的注意事项使用函数递归调用时，需要注意以下事项，以避免出现错误或导致程序异常：1. 设置递归终止条件：在递归函数中，必须设置一个递归终止条件，以确保递归调用会停止。
c语言直接递归和间接递归
c语言直接递归和间接递归递归是一种在函数内调用自身的编程技术。
递归分为直接递归和间接递归两种类型。
1. 直接递归（Direct Recursion）：在直接递归中，函数直接调用自身。
以下是一个简单的C 语言直接递归的例子，计算阶乘：```c#include <stdio.h>int factorial(int n) {if (n == 0 || n == 1) {return 1;} else {return n * factorial(n - 1);}}int main() {int num = 5;printf("Factorial of %d is %d\n", num, factorial(num));return 0;}```上述例子中，`factorial` 函数直接调用自身来计算阶乘。
2. 间接递归（Indirect Recursion）：在间接递归中，两个或多个函数相互调用，形成一个循环调用链。
以下是一个简单的 C 语言间接递归的例子，判断一个正整数是否为偶数：```c#include <stdio.h>// 声明函数isOdd，因为isEven 函数中会调用isOddint isOdd(int);int isEven(int n) {if (n == 0) {return 1; // 是偶数} else {return isOdd(n - 1);}}int isOdd(int n) {if (n == 0) {return 0; // 是奇数} else {return isEven(n - 1);}}int main() {int num = 6;if (isEven(num)) {printf("%d is even.\n", num);} else {printf("%d is odd.\n", num);}return 0;}```在上述例子中，`isEven` 函数调用`isOdd` 函数，而`isOdd` 函数又调用`isEven` 函数，形成了一个间接递归的关系。
C语言中函数嵌套调用和递归调用
函数嵌套与递归调用的区别
函数嵌套是语言特性，递归调用是逻辑思想。
1 函数嵌套
函数嵌套允许在一个函数中调用另外一个函数，比如有三个函数
例:
funca()
{
funcb();
}
funcb()
{
funcc();
}
funcc()
{
cout << "Hello" <<endl;
}
这个就叫做嵌套调用，它是一个语言提供的程序设计的方法，也就是语言的特性。
2 递归调用
而递归是一种解决方案，一种思想，将一个大工作分为逐渐减小的小工作，比如说一个和尚要搬50块石头，他想，只要先搬走49块，那剩下的一块就能搬完了，然后考虑那49块，只要先搬走48块，那剩下的一块就能搬完了……，递归是一种思想，只不过在程序中，就是依靠函数嵌套这个特性来实现了。
递归最明显的特点就是，自己调用自己。
例:
funca()
{
if(statement1)
funca();
else
exit(0);
}
3 总结
概括说，函数嵌套就是函数调用函数，是普遍的，递归就是函数调用自身，使函数嵌套的一个特例。
嵌套调用就是某个函数调用另外一个函数，递归调用是一个函数直接或间接的调用自己。
举几个例子：A调用B（嵌套）B调用C（嵌套）A调用A（递归）A 调用B B调用A （递归）A调用B B调用C C调用A （递归）。
c语言递归调用例子
c语言递归调用例子【篇一：c语言递归调用例子】* 小编已将正确代码放在左侧任务的“不知道怎么办”里* 小编希望各位童鞋独立完成哦~*///定义一个函数，传送人员序号进去，返回该序号员工的年龄。
int getage(numpeople) //定义返回的年龄 int age; //如果是第1个人的时候，年龄为10岁 if(numpeople==1) age=10; //这是回推墙，也就是结束递归的条件。
else //还没接触到回推墙，就自我调用，谓之递归。
age = getage(numpeople-1) //年龄等于上一个人的年龄加2 return age;int main() printf( 第5个人的年龄是%d岁 , getage(5));return 0;}【篇二：c语言递归调用例子】一、基本内容：c语言中的函数可以递归调用，即：可以直接（简单递归）或间接（间接递归）地自己调自己。
要点：1、c语言函数可以递归调用。
2、可以通过直接或间接两种方式调用。
目前只讨论直接递归调用。
二、递归条件采用递归方法来解决问题，必须符合以下三个条件：1、可以把要解决的问题转化为一个新问题，而这个新的问题的解决方法仍与原来的解决方法相同，只是所处理的对象有规律地递增或递减。
说明：解决问题的方法相同，调用函数的参数每次不同（有规律的递增或递减），如果没有规律也就不能适用递归调用。
2、可以应用这个转化过程使问题得到解决。
说明：使用其他的办法比较麻烦或很难解决，而使用递归的方法可以很好地解决问题。
3、必定要有一个明确的结束递归的条件。
说明：一定要能够在适当的地方结束递归调用。
不然可能导致系统崩溃。
三、递归实例例：使用递归的方法求n!当n 1时，求n!的问题可以转化为n*(n-1)!的新问题。
比如n=5：第一部分：5*4*3*2*1 n*(n-1)!第二部分：4*3*2*1 (n-1)*(n-2)!第三部分：3*2*1 (n-2)(n-3)!第四部分：2*1 (n-3)(n-4)!第五部分：1 （n-5）! 5-5=0，得到值1，结束递归。
c 函数递归 累加
c 函数递归累加C函数递归累加在计算机编程中，递归是一种常见的编程技术，可以在函数内部调用自身。
递归函数通常用于解决可以被分解成更小的子问题的问题。
C语言中也支持递归函数的使用，本文将介绍C语言中如何使用递归函数实现累加操作。
累加是一种常见的数学运算，它将一系列的数值相加得到一个总和。
在C语言中，我们可以使用递归函数来实现累加操作。
下面是一个简单的C函数递归累加的示例代码：```c#include <stdio.h>int recursiveSum(int n) {// 递归终止条件if (n == 0) {return 0;}// 递归调用自身，累加n和n-1的结果return n + recursiveSum(n - 1);}int main() {int num;printf("请输入一个正整数：");scanf("%d", &num);int result = recursiveSum(num);printf("从1累加到%d的结果为：%d\n", num, result);return 0;}```在上面的示例代码中，我们定义了一个名为`recursiveSum`的递归函数，该函数接收一个整数参数`n`，并返回从1累加到`n`的结果。
在函数的实现中，我们首先判断递归的终止条件，即`n`等于0时，直接返回0。
然后，我们通过调用自身，将`n`减1，并将结果与`n`相加，以实现递归累加的效果。
在`main`函数中，我们首先获取用户输入的一个正整数`num`，然后调用`recursiveSum`函数进行累加操作，最后将结果打印输出。
通过运行上述代码，我们可以得到从1累加到输入的正整数的结果。
例如，如果用户输入的是5，那么输出结果将是15，即1+2+3+4+5的值。
需要注意的是，递归函数的实现需要合理设计递归的终止条件，否则可能会陷入无限循环。
c语言用递归法计算n的阶乘
c语言用递归法计算n的阶乘
在C语言中，可以使用递归法来计算一个数的阶乘。
例如，要计算n的阶乘，可以使用以下代码：
```c
#include <stdio.h>
int factorial(int n) {
if (n == 0) {
return 1; // 0的阶乘为1
} else {
return n * factorial(n - 1); // 递归调用
}
}
int main() {
int n;
printf('输入一个整数：');
scanf('%d', &n);
printf('%d的阶乘为：%d', n, factorial(n));
return 0;
}
```
在这个代码中，我们定义了一个函数`factorial`，它接受一个整数参数n，返回n的阶乘。
如果n为0，则返回1（因为0的阶乘
为1）。
否则，递归调用`factorial`函数，传入n-1作为参数，并将其乘以n后返回。
在`main`函数中，我们首先读取一个整数n，并将其传入
`factorial`函数中计算阶乘。
最后，我们输出n的阶乘的值。
这种方法的优点是代码简单易懂，但当n很大时会导致栈溢出。
因此，在实际编程中要注意选择合适的算法来计算阶乘。
C语言递归调用实例——汉诺塔问题动画实现(附完整代码)
二、程序框架
古人云，不谋全局者，不足谋一域。同样，在编写代码之前，我们必 须得有个大体的思路和整体上的把握。不能一上来就稀里糊涂地乱敲一通。 当然，这里我也只能仅仅谈自己的个人想法，不一定就是最优的解决方案， 还希望能和大家一起相互交流，共同进步。整个程序的框架，我把它分为 动画效果和核心算法两大部分。我首先实现的是动画效果部分，等能够实 现盘子的随意移动后，我才开始研究核心算法的实现。这样一来，在核心 算法部分，我们正好可以利用前面的动画效果来直观地反映出我们的思路， 有助于代码的调试和缩短程序的开发周期。为了尽量减少废话，我们可以 用一张图来进行表示：
图 1-1 移动第一个圆盘..................................................................................................................... 4 图 1-2 移动第二个圆盘...................................................................................................................... 5 图 1-3 移动最后一个圆盘................................................................................................................. 6
能移动一个圆盘，且圆盘在放到棒上时，大的不能放在小的上面。中间的一根
棒作为辅助移动用。” 事实上，对此曾经有人作过分析，按这个规则，众僧耗尽毕生精力也
不可能完成圆盘的移动，因为需要移动圆盘的次数是一个天文数字 18446744073709551615（64 个圆盘需要移动的次数为 2 的 64 次方）。假设 1us 进行一次移动，也需要约一百万年的时间，使用计算机也很难解决 64
c语言中如何返回之前的步骤
c语言中如何返回之前的步骤在C语言中，要返回之前的步骤，可以使用函数的递归调用或者栈的数据结构来实现。
下面分别介绍这两种方法。
一、递归调用递归调用是一种函数调用自身的方式。
通过递归调用，可以实现函数返回之前的步骤。
1.递归调用的基本原理递归调用的基本原理是在函数内部调用自身，通过在每一次递归调用中传递不同的参数，让函数按照不同的路径执行，最终返回之前的步骤。
2.递归调用的步骤（1）定义递归函数：在函数内部定义一个递归函数，用于实现递归调用。
（2）设置递归终止条件：在递归函数的开头设置一个递归终止条件，当满足此条件时，不再进行递归调用，直接返回。
（3）设置递归调用：在递归函数内部，根据条件判断是否进行递归调用，若进行递归调用，则传入不同的参数。
（4）返回值：在递归函数中，根据需要返回相应的值。
3.递归调用的示例下面以计算阶乘的函数为例，介绍递归调用的实现过程。
```c#include <stdio.h>int factorial(int n)if(n == 0)return 1; // 终止条件elsereturn n * factorial(n-1); // 递归调用int mainint num;printf("请输入一个非负整数：");scanf("%d", &num);printf("%d的阶乘为%d\n", num, factorial(num));return 0;```以上代码中，factorial函数是一个递归函数，根据n的不同值，通过递归调用来实现计算阶乘的功能。
当n为0时，满足递归终止条件，函数直接返回1；否则，函数通过递归调用返回n * factorial(n-1)的结果。
二、栈的数据结构栈是一种后进先出（LIFO）的数据结构，可以通过栈来实现返回之前的步骤。
1.栈的基本操作（1）入栈（push）：将元素压入栈顶。
递归实现斐波那契数列c语言
递归实现斐波那契数列c语言
斐波那契数列是指一个数列，其中每个数字都是前面两个数字的和。
公式表示为：F(n)=F(n-1)+F(n-2)，其中F(0)=0，F(1)=1。
以下为递归实现斐波那契数列的C语言代码：
```c
#include<stdio.h>
int fibonacci(int n)
{
if(n <= 1)
return n;
else
return fibonacci(n-1) + fibonacci(n-2);
}
int main()
{
int n, i;
printf("请输入斐波那契数列的项数：");
scanf("%d", &n);
printf("斐波那契数列的前 %d 项为：\n", n);
for(i=0; i<n; i++)
{
printf("%d ", fibonacci(i));
}
printf("\n");
return 0;
}
```
在程序中，函数fibonacci()用递归的方法求解斐波那契数列的
第n项。
在main()函数中，读入要求的斐波那契数列的项数，然后调用函数fibonacci()求解前n项斐波那契数列并输出。
fibonacci数列c语言递归算法
fibonacci数列c语言递归算法==================Fibonacci数列是一个非常著名的数列，其中的数字通过简单的递归关系生成。
在这个数列中，每个数字是前两个数字的和。
这个数列的名称来源于Fibonacci本人，因为他提出了这个数列并解决了如何生成它的方法。
以下是一个用C语言实现的Fibonacci数列的递归算法：```c#include <stdio.h>// 定义一个函数来计算Fibonacci数列的下一个数字int fibonacci(int n) {if (n <= 1) {return n;} else {return fibonacci(n - 1) + fibonacci(n - 2);}}int main() {int i;for (i = 2; i <= 10; i++) { // 这里仅演示Fibonacci数列的前几个数字，你可以更改这个范围来查看更多的数字printf("Fibonacci number %d: %d\n", i, fibonacci(i));}return 0;}```这段代码首先定义了一个名为`fibonacci`的函数，该函数接受一个整数参数`n`，并返回Fibonacci数列中的第`n`个数字。
如果`n`小于或等于1，函数直接返回`n`，因为Fibonacci数列的前两个数字就是1和1。
否则，函数递归地调用自身来获取前两个数字，并将它们相加得到结果。
在`main`函数中，我们使用一个循环来计算并打印出前几个Fibonacci数。
注意，这段代码只会打印出Fibonacci数列的前几个数字，你可以根据需要更改循环的范围来查看更多的数字。
这就是一个简单的递归算法来生成Fibonacci数列。
这种算法在理论上可以生成任意大的数列，但是实际的运行时间会随着数列的增大而显著增加，因为每次递归调用都需要额外的计算资源。
c语言函数之递归函数
c语言函数之递归函数朱有鹏1、递归函数1.1、函数的调用机制C语言函数的调用一般在X86平台是用栈的方式来支持其操作的（也就是Calling Convention），栈是先进后出的数据结构，当函数发生调用的时候，函数以入栈的方式，将函数的返回地址、参数等进行压栈，C语言默认环境下的调用规范为，参数是从右向左依次压栈（如：printf函数），这就是函数的调用机制。
同时函数每调用一次，就会进行一次压栈，其所占的空间彼此独立，调用函数和被调用函数依靠传入参数和返回值彼此联系。
如: 一个main()函数调用函数sub（int a, int b）的简单的内存图形是：入栈int aInt bsub()返回地址main参数main()返回地址栈1.2、递归函数（1）什么是递归函数？通过简单的了解函数的调用机制，在程序设计中经常会用递归函数解决问题，此方法清晰易于理解。
那么什么是递归函数呢？递归函数的本质就是函数直接或间接调用其函数本身。
直接调用函数调用本身示例：求n的阶乘？factorial()函数直接调用其本身。
间接调用是函数调用其它函数，其它函数又调用其本身函数示例：func_1()函数中调用了func_2() 函数,func_2()函数又调用了func_1() 这样的方式就是间接递归，此示例，本身就是个错误，各位不要急后面一一道来（没有注意收敛性）。
（2）递归的调用的原理比如下例：#include<stdio.h>void recursion(int n) {printf("递归前：n = %d.\n", n); if (n > 1) {recursion(n-1);} else {printf("结束递归，n = %d.\n", n); }printf("递归后：n = %d.\n", n); }int main(void){void recursion(3);}执行结果为：递归前：n = 3.递归前：n = 2.递归前：n = 1.结束递归，n = 1.递归后：n = 1.递归后：n = 2.递归后：n = 3.函数的执行顺序，如图所示:解析：当程序执行时，通过主函数执行到void recursion(3);时，以n=3进入recursion函数中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
}
int AddFun(int n)
{
if(n == 1)
{
return 1;
}
return AddFun(n-1) + 2;
}
这里呢AddFun(n)就是之前看到的a(n)，在调用的过程中先判断n是否为1，如果为1当然就表示现在是首项了，不在继续调用，直接返回结果1
if(n < 6)
{
Test_1( n + 1 );
}
}
2、
void Test_2(int n)
{
if(n < 6)
{
Test_2( n + 1 );
}
cout<<n<<endl;
}
如果在main()函数中分别调用这两个函数，会有什么执行结果呢？
现在我们假定n为0
递归调用即递推关系
递归三个注意：注意递推表达、注意临界判断、注意递归体
下面留下一个练习，有时间再写答案吧.
快速排序法
提示：先从数据序列中选一个元素,并将序列中所有比该元素小的元素都放到它的右边或左边,再对左右两边分别用同样的方法处之直到每一个待处理的序列的长度为1
那么就可以利用叠加的方法来计算了：
假设这里首项为1，也就是a(1)=1，而这个常数就为2
那么
a(n)=a(n-1)+2
a(n-1)=a(n-2)+2
a(n-2)=a(n-3)+2
a(n-3)=a(n-4)+2
...
a(3)=a(2)+2
a(2)=a(1)+2
将等号左边的依次相加，右边的也依次相加
头尾分开，就是将两个cout<<n<<endl分开，第一个cout<<n<<endl执行，然后转入第一次递归，等待递归结束后回到第二个cout<<n<<endl语句执行
这样说很抽象，我们一步步分析一下
第一次调用，n=1
执行头cout<<n<<endl，输出1，并且尾cout<<n<<endl等待，其值也是1，但未输出；
第一个函数打印出
0
1
2
3
4
5
6
第二个函数打印出
6
5
4
3
2
1
0
这个就很奇怪了，这是为什么呢？
实际上前面我们考虑的递归关系是单一的递归，但是这两个递归体中，除了完成递归外，还有其他执行代码.
其实之前也有，只是没有显示出来，就没有被察觉而已
那么怎么去分析呢？
其实很简单，递归体本身可分为三个部分，一个是头代码，一个是递归表达式，一个是尾代码，区分头尾的自然就是递归表达式了
例如：楼梯有n阶台阶,上楼可以一步上1阶,也可以一步上2阶,编一程序计算共有多少种不同的走法.
先来分析一下，如果只有一个台阶，那么显然只有1种，所以a(1)=1
如果有两个台阶，呢么就有每次上一层，上两次，和一次上两层，即1+1和2共2种，即a(2)=2
当n=3时，那么就有1+1+1、1+2、2+1共3种了，似乎还看不出规律，那么分析一下递推关系，即前后项间的关系
下面看看用代码来实现，还是假定首项为1，公差为2
#include <stdio.h>
int main()
{
int AddFun(int);
int num;
printf("Please input num:");
scanf("%d",&num);
printf("The result is %d",AddFun(num));
其实说到递归，大伙都知道就是自己调自己，这样其实大家都明白，但是说来怎么调？如何控制？又如何看得到结果是想要的呢？相信还是很晕，下面从中学数学里面来看看吧.
第一部分、两个典型的例子，等差数列与等比数列
其实这实际上是一个例子，教书的时候我常常会问学生：“什么是等差数列？”当然同学们都会回答：“就是后一项总比前一项多一个数，这个数不变...”也有的说：“就是后一项减去前一项为一定常数...”
（递推关系为a(n)=2a(n-1)+1，a(1)=1）
参考代码：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int SumCon(int n);
printf("%d",SumCon(10));
return 0;
可以写成
#include <iostream>
using namespace std;
int main()
{
int res = 1;
for(int i=1; i <10; i++)
{
res = res * 2;
}
cout<<res<<endl;
return 0;
到达第三层有两个方法，一是从第二层走一步到第三层，那么有a(2)种方法，又可以从第一层走两步到第三层，即a(1)种方法，拍脑袋了，显然到达第三层有a(1)+a(2)种方法，那么是不是呢？验证一下
a(1)+a(2)=1+2=3，咦，正好，看来有点像了，再来看看第四层是不是
当n=4时，按照上边的分析肯定为a(2)+a(3)=2+3=5，下面我们枚举一下：1+1+1+1、1+1+2、1+2+1、2+1+1、2+2，刚刚好，看来就是她了！
那么代码就可以这么写了：
int Count(int n)
{
if(2 == n)
{
return 2;
}
else if(1 == n)
{
return 1;
}
return Count( n - 1 ) + Count( n - 2 );
}
实际上这就是一个典型的Fibonacci数列，只是初始值不同罢了，下面留两个练习（著名的数列）：
这样很容易发现，左边有一部分从a(2)一直加到a(n-1)，右边也有一部分从a(2)一直加到a(n-1)，那么消去，就左边剩下a(n)，右边就剩下a(1)和n-1个2相加了，数学公式就成了
a(n)=a(1)+2(n-1)
即
a(n)=1+2(n-1)
LaTeX代码为
\[a_n=1+2(n-1)\]
}
int SumCon(int n)
{
if(n<=0)
{
return 1;
}
return 2 * SumCon( n - 1 ) + 1;
}
当然递归不一定要调用函数开完成，使用for循环一样可以做到
比如还是公比为2，首项为1的等比数列求第10项的值
那么递推关系就有了，即a(n)=a(n-1)+a(n-2)，同时还有了首项的值：a(1)=1，a(2)=2，由于递推关系有三项，很显然必须有两个初始值
好啦，上面讨论了递归的一个注意，下面是第二个注意，临界条件
既然递归就是自己调自己，那么怎么停止呢，显然不做逻辑判断，计算机会一直运行下去，知道程序崩溃（栈溢出），所以就需要加上一个if判断来跳出递归，其实就是前面提到的数列首项，就是这里的a(1)和a(2)
递归调用——数学观点看递归20110321
想起上大学那会儿递归调用曾是那么令人头痛，现在教书也近两年时间了，对递归倒是有了较明晰的了解.
递归，数学里面叫recursion，其实就是递推关系. 中学数学有一部分其实就是递归的非常典型的做法，不过老师们都没怎么扩展，新课标必修五第二章数列应该算是我们第一次接触递推的概念了.
这里使用的不是数学中的公式计算，纯粹的事利用递推关系得到的结果.
再看看等比数列. 相信已经很清楚了，等比数列就是后一项是前一项的定常数被，表示为
a(n)=a(n-1)*q
LaTeX代码为
\[a_n=a_{n-1}\cdot q\]
将函数改一改就能使用了，假设首项为1，公比为2：
int ProductFun(int n)
{
if(n == 1)
{
return 1;
}
return AddFun(n-1)*2;
}
那么留个练习，这可是一道高中数学的典型例题(LaTeX代码)：
已知数列~$\{a_n\}$~满足~$a_n = 2a_{n-1}+1$，且首项~$a_1 = 1$，用递归调用写出代码过程.
{
Test( n + 1 );
cout<<n<<endl;
}
}
输出结果为
1
2
3
2
1
那么在这段代码中if()前面的输出流为头代码，中间的Test( n + 1 )为递归表达式，这里的尾代码依然是一个输出流
那么分析此程序怎么做呢？很简单，八个字
“头尾分开，等待归来”
1、反Fibonacci数列，满足的递推关系为：a(n+2)=a(n)-a(n+1)