函数的递归调用1
子程序调用自己称为递归调用
递归子程序调用自己称为递归调用，用自身的简单情况来定义自己。
如⑴求n!⎪⎩⎪⎨⎧⨯-=n n )!1(1n!⑵斐波纳契数列⎪⎪⎩⎪⎪⎨⎧-+-=)2()1(10fib(n)n fib n fib⑶给定n （n>=1），求1+2+3+…+n 的值。
设s(n)=1+2+3+…+(n-1)+n则 ⎪⎩⎪⎨⎧+-=nn s n s )1(1)(能用递归算法求解的的问题一般应该满足如下要求：⑴符合递归的描述：需要解决的问题可以化为子问题求解，而子问题求解的方法与原问题相同，只是数量增大与减少；⑵递归调用的次数是有限的；⑶必须有递归的结束条件。
归纳起来递归的两个条件：⑴递归有边界条件。
⑵递归形式。
当n=0时 当n>0时当n=1时 当n=2时 当n>2时当n=1时当n>1时例 1、求n!分析：根椐数学知识，0!=1，正整数N的阶乘为：N*(N-1)*(N-2)*…*2*1，该阶乘序列可转换为求N*(N-1)!，而(N-1)!以可转换为(N-1)*(N-2)!，……，直至转换为1*0!，而0!=1。
源程序如下:program ex;function f(n:integer):longint;beginif n=0 then f:=1 {递归边界}else f:=f(n-1)*n {递归形式}end;begin {main}writeln(f(3))end.在过程f中，当n>1时，又调用过程f，参数为n-1，…，这种操作一直持续到n=0为止。
例如当n=5时，f (5)的值变为5*f (4)，求 f ( 4)又变为4*f (3)，…，当n= 0时递归停止，逐步返回到第一次调用的初始处，返回结果5*4*3*2*1，即5!。
例2、斐波纳契数列0、1、1、2、3、5、8、13、21、34、……从第三项开始，每一项都是紧挨着的前两项之和。
编程求该数列第n项。
分析：我们已经知道菲波纳葜数列的各数列的产生可用下列公式表示：f(1)＝０f(2)＝１ f(n)＝f(n-1)＋f(n-2) （当n>2时）因此当n大于2时，求第n项值可转化为求第n-1项值与第n-2项值的和；而求第n-1项又可转化为求n-2项值与n-3项的和，相应地，求n-2项值可转化为求n-3项值和n-4项值的和；……；如此反复，直至转化为求第1项或第2项值，而第 1项与第2项为已知值0和1。
matlab function 递归函数
MATLAB递归函数1. 引言MATLAB是一种功能强大的数值计算和科学编程语言，具有丰富的函数库和工具箱。
递归函数是一种特殊类型的函数，它在函数体内调用自身。
递归函数在解决一些复杂问题时非常有用，可以将一个大问题分解成一个或多个更小的子问题进行求解。
本文将详细介绍MATLAB递归函数的定义、用途和工作方式，以及如何编写递归函数来解决实际问题。
2. 函数的定义递归函数是一种在函数体内调用自身的函数。
它可以通过将一个问题分解成更小的子问题来解决复杂的问题。
递归函数通常具有以下几个要素：•基本情况（Base case）：递归函数必须包含一个或多个基本情况，即函数不再调用自身的情况。
基本情况通常是一个简单的问题，可以直接求解而不需要进一步的递归调用。
•递归调用（Recursive call）：递归函数在函数体内调用自身，并将问题规模缩小为一个或多个子问题。
递归调用通常在某个条件满足时发生，否则函数将陷入无限循环。
•问题规模缩减（Problem reduction）：递归函数通过将一个大问题分解成一个或多个更小的子问题来解决复杂的问题。
每次递归调用都会将问题的规模缩小，直到达到基本情况。
3. 递归函数的用途递归函数在解决一些复杂问题时非常有用，特别是那些可以通过将问题分解成更小的子问题来解决的情况。
递归函数的用途包括但不限于以下几个方面：•分治法（Divide and conquer）：递归函数可以将一个大问题分解成一个或多个更小的子问题，并将子问题的解合并成原问题的解。
分治法通常用于解决一些需要分解成子问题的问题，例如排序、搜索和图算法等。
•树和图的遍历：递归函数可以用于树和图的遍历，例如深度优先搜索（DFS）和广度优先搜索（BFS）。
递归函数可以通过递归调用来遍历树和图的节点，并在每个节点上执行相应的操作。
•动态规划：递归函数在动态规划中也经常被使用。
动态规划是一种通过将问题分解成更小的子问题来求解的优化技术。
递归函数reverse
递归函数reverse
递归函数reverse是一种可以用来翻转列表或字符串的函数。
它通过递归调用自身来实现翻转的过程。
具体来说，如果我们要翻转一个列表或字符串，可以先将其第一个元素或字符和最后一个元素或字符交换，然后再对剩余的元素或字符进行翻转操作。
这个过程可以用递归函数来实现，即每次递归调用时传入剩余的部分，直到只剩下一个元素或字符为止。
最终，所有元素或字符都被翻转过来了，得到了一个新的列表或字符串，其顺序与原来相反。
递归函数reverse的实现方式有很多种，但其基本思想都是相同的。
- 1 -。
C19-函数(二)
数组元素作为函数实参
数组元素作为函数参数
实例19-4：统计字符串中字母的个数。
int isalp(char c) { if(c>='a'&&c<='z'||c>='A'&&c<='Z') return(1); else return(0); }
main( ) { int i,num=0; char str[255]; printf("Input a string: "); gets(str); for(i=0;str[i]!='\0';i++) if (isalp(str[i])) num++; puts(str); printf("num=%d\n",num); }
比如n=5： 第一部分：n!=n*(n-1)!=5*4! 第二部分：(n-1)!=(n-1)*(n-2)!=4*3! 第三部分：(n-2)!=(n-2)*(n-3)!=3*2! 第四部分：(n-3)!=(n-3)*(n-4)!=2*1! 第五部分：(n-4)!=(n-4)*(n-5)!=1，得到值1，结束递归。
printf(“max=%d\n”,m);
}
{
return((x>y)? x:y); }
函数的嵌套调用 实例19-2：计算 s 1 2 3 n
k k k k
#define K 4 #define N 5 main( ) { printf(“Sum of %d powers of integers from 1 to %d = ”, Ｋ,Ｎ); printf(“%d\n”,f2(Ｎ,Ｋ));
python递归斐波那契数列前n项
python递归斐波那契数列前n项Python是一种强大的编程语言，它支持递归函数的使用，这使得我们可以很方便地计算斐波那契数列的前n项。
斐波那契数列是一个非常经典的数列，它的定义是每一项都是前两项的和，即f(n) = f(n-1) + f(n-2)，其中f(0) = 0，f(1) = 1。
在这篇文章中，我将通过Python递归函数来实现斐波那契数列的计算，并展示前n项的结果。
我们需要定义一个递归函数来计算斐波那契数列的每一项。
我们可以使用if语句来处理边界情况，即当n等于0或1时直接返回相应的值。
对于其他情况，我们可以通过递归调用函数来计算前两项的和。
下面是Python代码实现：```pythondef fibonacci(n):if n == 0:return 0elif n == 1:return 1else:return fibonacci(n-1) + fibonacci(n-2)```接下来，我们可以编写一个函数来输出斐波那契数列的前n项。
我们可以使用一个循环来迭代输出每一项的值，并将结果存储在一个列表中。
下面是Python代码实现：```pythondef print_fibonacci(n):fibonacci_list = []for i in range(n):fibonacci_list.append(fibonacci(i))return fibonacci_list```现在，我们可以使用上述函数来计算并输出斐波那契数列的前n项。
下面是一个示例，展示如何计算并打印斐波那契数列的前10项：```pythonn = 10fibonacci_sequence = print_fibonacci(n)for i in range(n):print(fibonacci_sequence[i], end=" ")```运行上述代码，我们将得到斐波那契数列的前10项：0 1 1 2 3 5 8 13 21 34。
中南大学daydayupt题库中的全部判断题
正确
题目
若有定义：int a[ ][4]={{0}，{1}};，则数组a包含8个元素。
正确答案
正确
题目
若有定义：int a[ ][3]={0,1,2,3,4,5,6,7};，则数组a包含9个元素。
正确答案
正确
题目
若有定义：int a[ ][5]={0,1,2,3,4,5,6,7,8};，则数组a包含9个元素。
正确答案
正确
题目
在C++中，空指针用NULL表示。
正确答案
正确
题目
在C++中，变量的指针就是变量的地址。
正确答案
正确
题目
假设有：int a[5]，*p=a；，则*++a与*++p相等。
正确答案
错误
题目
将函数定义的首部int sum( int x[ ] , int n )改写成int sum( int * x , int n )编译不会出错，即效果等价。
正确答案
正确
题目
将函数声明int sum( int [ ] , int );改写成int sum( int *, int );编译不会出错，即效果等价。
正确答案正确题目一个类的保护成员仅可以被其自己和派生类的所有非静态成员函数和友元函数直接访正确答案正确题目基类中的私有成员在通过公有派生的子类中是不能被直接访问的正确答案正确题目一个类中的私有成员只能被它们所在类的成员函数访问正确答案错误题目基类中的公有成员在通过私有派生的子类中具有private访问属性正确答案正确题目基类中的公有成员在通过保护派生的子类中具有public访问属性正确答案错误题目基类中的公有成员在通过私有派生的子类中具有public访问属性正确答案错误题目当派生类从基类公有继承时可以把指向基类对象的指针赋给派生类对象的指针正确答案错误题目基类中的保护成员在通过私有派生的子类中具有private访问属性正确答案正确题目当派生类从基类公有继承时可以把派生类对象的地址赋给基类对象的指针正确答案正确题目基类中的保护成员在通过私有派生的子类中具有protected访问属性正确答案错误题目当派生类从基类公有继承时可以把基类对象的地址赋给派生类对象的指针正确答案错误题目基类中的保护成员在通过保护派生的子类中具有protected访问属性正确答案正确题目基类中的保护成员在通过保护派生的子类中具有private访问属性正确答案错误题目基类中的公有成员在通过保护派生的子类中具有protected访问属性正确答案正确题目基类中的公有成员在通过公有派生的子类中具有public访问属性正确答案正确题目当派生类从基类公有继承时可以把指向派生类对象的指针赋给基类对象的指针正确答案正确题目基类中的公有成员在通过公有派生的子类中具有protected访问属性正确答案错误题目基类中的保护成员在通过公有派生的子类中具有public访问属性正确答案错误题目基类中的保护成员在通过公有派生的子类中具有protected访问属性正确答案正确题目基类中的私有成员在通过私有派生的子类中是可以被直接访问的正确答案错误题目多态性只能在编译的时候实现
真实系统的递归效应
真实系统的递归效应
递归效应是指一个函数或算法在执行过程中，会调用自身，从而形成一种自我包含的结构。
在真实系统中，递归效应可以表现为以下几种情况：
1. 递归调用自身：在编程中，递归是一种常见的算法，例如斐波那契数列、阶乘等。
在递归算法中，函数会反复调用自身，直到达到某个条件才停止。
这种递归调用会形成一种自我包含的结构，可以用于解决一些复杂的问题。
2. 递归调用其他函数：除了调用自身，递归还可以调用其他函数。
例如，一个函数可以调用另一个函数来完成某个任务，而另一个函数又可以调用第一个函数来完成另一个任务。
这种递归调用可以形成一种嵌套的结构，可以使代码更加简洁和易于理解。
3. 递归调用事件处理函数：在图形用户界面（GUI）编程中，递归调用事件处理函数是一种常见的技巧。
例如，一个按钮可以触发一个事件处理函数，该函数又可以调用另一个事件处理函数来完成一些操作。
这种递归调用可以使代码更加灵活和易于扩展。
然而，递归效应也可能会导致一些问题。
例如，递归调用可能会导致栈溢出错误，因为每次递归调用都会在栈
中创建一个新的帧。
如果递归调用的深度过深，栈就会被耗尽，从而导致程序崩溃。
此外，递归调用还可能会导致性能问题，因为每次调用都需要进行一些额外的操作。
因此，在使用递归时，需要仔细考虑其影响，并采取适当的措施来避免潜在的问题。
递归函数的返回值
递归函数的返回值
递归函数的返回值是指在一个递归函数中执行一次递归调用后，
返回给上一层函数的值。
在递归函数中，每一层函数都会再次触发更
深层次的函数调用，直到递归到最深层的情况下才开始返回值。
递归函数需要有两个部分，递归条件和终止条件。
递归条件指的
是在执行当前函数时，需要调用自身函数的条件。
而终止条件则是指
达到了所设定的条件后，函数将不再递归调用自身函数，而是开始向
上返回调用值。
递归函数的返回值可以有多种类型。
最简单的是整数类型，例如
阶乘函数，斐波那契数列等。
在这种情况下，每一次函数调用都会返
回一个整数值。
而对于一些需要返回数组、指针等类型的递归函数，需要注意每
一层递归调用所产生的返回值在返回后是否仍然有效。
在这些情况下，可以通过传递引用、指针等方式将返回值传递到上一层递归调用中。
递归函数的返回值也可以是布尔类型，例如在二叉搜索树中递归
查找某一节点时，如果该节点不存在，函数将返回 false。
需要注意的是，在编写递归函数时，应该注重其收敛性。
如果没
有正确的终止条件，函数将会陷入无限循环，导致程序崩溃。
同时，
也需要注意递归深度过大的情况，可能会导致栈溢出等问题。
总之，递归函数的返回值是指在函数调用结束后返回给上一层调
用函数的值。
对于不同类型的递归函数，需要注意返回值的传递方式
以及对终止条件的控制。
在编写递归函数时，避免出现无限循环等问
题是非常重要的。
递归算法
前言说白了递归就象我们讲的那个故事：山上有座庙，庙里有个老和尚，老和尚在讲故事，它讲的故事是：山上有座庙，庙里有个老和尚，老和尚在讲故事，它讲的故事是：……也就是直接或间接地调用了其自身。
就象上面的故事那样，故事中包含了故事本身。
因为对自身进行调用，所以需对程序段进行包装，也就出现了函数。
函数的利用是对数学上函数定义的推广，函数的正确运用有利于简化程序，也能使某些问题得到迅速实现。
对于代码中功能性较强的、重复执行的或经常要用到的部分，将其功能加以集成，通过一个名称和相应的参数来完成，这就是函数或子程序，使用时只需对其名字进行简单调用就能来完成特定功能。
例如我们把上面的讲故事的过程包装成一个函数，就会得到：void Story(){puts("从前有座山，山里有座庙，庙里有个老和尚，老和尚在讲故事，它讲的故事是：");getchar();//按任意键听下一个故事的内容Story(); //老和尚讲的故事，实际上就是上面那个故事}函数的功能是输出这个故事的内容，等用户按任意键后，重复的输出这段内容。
我们发现由于每个故事都是相同的，所以出现导致死循环的迂回逻辑，故事将不停的讲下去。
出现死循环的程序是一个不健全的程序，我们希望程序在满足某种条件以后能够停下来，正如我们听了几遍相同的故事后会大叫：“够了！”。
于是我们可以得到下面的程序：#include<stdio.h>const int MAX = 3;void Story(int n);//讲故事int main(void){Story(0);getchar();return 0;}void Story(int n){if (n < MAX){puts("从前有座山，山里有座庙，庙里有个老和尚，老和尚对小和尚说了一个故事：");getchar();Story(n+1);}else{printf("都讲%d遍了！你烦不烦哪？\n", n);return ;}}上面的Story函数设计了一个参数n，用来表示函数被重复的次数，当重复次数达到人们忍受的极限（MAX次）时，便停下来。
实验报告函数的用法(3篇)
第1篇一、实验目的1. 理解函数的概念及作用。
2. 掌握函数的声明、定义和调用方法。
3. 学习函数的参数传递和返回值。
4. 熟悉函数的嵌套调用和递归调用。
二、实验原理函数是程序设计中的一种基本概念，它将一系列具有特定功能的代码封装在一起，以便重复使用。
函数的主要作用是将复杂的程序分解为多个模块，提高代码的可读性和可维护性。
在C语言中，函数分为两大类：标准函数和自定义函数。
标准函数是C语言库函数，如printf()、scanf()等；自定义函数是由程序员根据实际需求编写的函数。
函数的基本结构如下：```c函数返回类型函数名(参数列表) {// 函数体}```三、实验内容1. 函数的声明函数声明用于告诉编译器函数的存在，包括函数名、返回类型和参数列表。
函数声明格式如下：```c函数返回类型函数名(参数类型参数名);```2. 函数的定义函数定义是函数声明的具体实现，包括函数名、返回类型、参数列表和函数体。
函数体由大括号{}包围，包含一系列执行语句。
```c函数返回类型函数名(参数类型参数名) {// 函数体}```3. 函数的调用函数调用是指程序中调用函数的过程。
调用函数时，需要按照函数的参数列表提供相应的实参。
```c函数名(实参1, 实参2, ..., 实参n);```4. 函数的参数传递函数的参数传递主要有两种方式：值传递和地址传递。
（1）值传递：将实参的值复制给形参，函数内部对形参的修改不会影响实参。
（2）地址传递：将实参的地址传递给形参，函数内部通过修改形参的地址来修改实参的值。
5. 函数的返回值函数的返回值是指函数执行完毕后返回给调用者的值。
函数返回值类型必须与函数声明时指定的返回类型一致。
6. 函数的嵌套调用函数嵌套调用是指在一个函数内部调用另一个函数。
嵌套调用的函数可以递归调用自身。
7. 函数的递归调用递归调用是指函数在执行过程中直接或间接地调用自身。
递归调用分为直接递归和间接递归两种。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include “stdio.h” 问题一： 问题一：程序中哪些地 fun1(int a,int b) 方使用了函数调用？ 方使用了函数调用？ {int c; 分别是谁调用了谁？ 分别是谁调用了谁？ a+=a;b+=b; c=fun2(a,b); return c*c; 问题二： 问题二：程序的运行结果 } 是怎样的？ 是怎样的？你是怎样分析 fun2(int a,int b) {int c; 得到的？ 得到的？ c=a*b%5; return c; } 运行结果： 运行结果：9 main() {int x=21,y=12; printf(“%d\n”,fun1(x,y)); }
评 语
返 回
返 回
填空题 1、函数调用中的实参必须与被调函数 中的形参一一对应，即实参和形参在 顺序 个数 类型 _____ 、_____ 、_____上必须一致。 直接递归调用 2、函数的递归调用分为___________ 间接递归调用 和_____________。 3、C语言程序中，若对函数类型未加 整型 显式说明，则函数的类型为：______
用递归方法求n! 例题二 用递归方法求
分析：假设 分析：假设n=5 我们知道 5！=1*2*3*4*5=4！*5 ！ ！ 4！=1*2*3*4=3！*4 ！ ！ 3！=1*2*3=2！*3 ！ ！ 2！=1*2=1！*2 ！ ！ 1！=1 ！ 可用下面的递归公式表示
n!=1 （n=1） ） n!=(n-1)!*n (n> 1)
努力 成人
自信 成才
请各小组自由选题
选择题 1、以下函数的类型是（C 、以下函数的类型是（ ）
func(doule x); {printf(“%f\n”,x*x);} A.与参数 的类型相同 B.void类型 C.int类型 与参数x的类型相同 与参数 类型 类型 D.无法确定 无法确定 2、以下函数调用语句中，含有的实参个数是（C） 、以下函数调用语句中，含有的实参个数是（ func(exp1,(exp2,exp3),(exp4,exp5,exp6)); A.1 B.2 C.3 D.4 3、以下所列的各函数首部中，正确的是（C） 、以下所列的各函数首部中，正确的是（ A、void play(var a:interger, var b:interger) 、 B、 void play(int a,b) C、 void play(int a,int b) 、 、 D、sub play(a as interger,b as interger) 、
#include “stdio.h” fac（ long fac（n） int n; {long f; if（ =1）f=1； if（n= =1）f=1； else fac（ f＝fac（n-1）*n; return（ return（f）； } main（） main（） {int n; scanf(“%d”,&n); printf(“%d!=%ld\ printf(“%d!=%ld\n”,n,fac(n)); }
评 语
试编程序
用递归法求Fibonacci数列的第6项项值
stdio.h” #include “stdio.h stdio.h fib(int n) {int f; if(n= =1||n= =2) f=1; f=fib(n-1)+fib(nelse f=fib(n-1)+fib(n-2); return f; } main () printf("%d\ { printf("%d\n",fib(6));}
可以用一个函数来描述上述递归过程： 可以用一个函数来描述上述递归过程： age（ age（n） /*求年龄的递归函数*／ /*求年龄的递归函数 求年龄的递归函数* n； int n； ｛int c； c； ／* c用来存放函数的返回值*/ 用来存放函数的返回值* if（ =1） if（n= =1） c=10; c=age（ else c=age（n一1）十2； return（c)； return（c)； } main（） main（） {printf（"%d"，age（ ））；} {printf（"%d"，age（5））；} ，
age(5) =age(4)+2 age(4) =age(3)+2 age(3) =age(2)+2 age(2) =age(1)+2 age(1) =10
age(5) =18
回 推
递 推
age(4) =16 age(3) =14 age(2) = 12
从图可知，求解可分成两个阶段：第一阶段是“回 从图可知，求解可分成两个阶段：第一阶段是“ 推”，即将第n个人的年龄表示为第（n-1）个人年 ，即将第n个人的年龄表示为第（n 龄的函数，而第（n 龄的函数，而第（n一1）个人的年龄仍然不知道， 还要“回推”到第（n 还要“回推”到第（n一2）个人的龄……，直到第1 ）个人的龄……，直到第1 个人的年龄。此时age(1)已知，不必再向前推了。 个人的年龄。此时age(1)已知，不必再向前推了。 然后开始第二阶段，采用递推 然后开始第二阶段，采用递推方法，从第1个人的 递推方法，从第1 已知年龄推算出第2个人的年龄（12岁），从第2 已知年龄推算出第2个人的年龄（12岁），从第2个 人的年龄推算出3个人的年龄（14岁）……，一直推 人的年龄推算出3个人的年龄（14岁）……，一直推 算出第5个人的年龄（18岁）为止。也就是说，一 算出第5个人的年龄（18岁）为止。也就是说，一 个递归的题可以分为“回推”和“递推”两个阶 段。要经历许多步才能求出最后的值。显而易见， 如果求递归过程不是无限制进行下去，必须具有一 个结束递归过程的条件。 例如，age（ ）＝10，就是递归结束的条件。 例如，age（1）＝10，就是递归结束的条件。
评 语
1、什么是函数的递归调用？ 2、递归调用的分类 3、递归调用的两个过程 4、递归调用的算法表述为： if（递归终止条件） return（条件终止时的值） else return 递归公式
编程解决汉诺塔问题
问题: 杆上n个盘子移至C(借助于B) C(借助于B)。 移动时, 问题: 将A杆上n个盘子移至C(借助于B)。 移动时, 保证三个杆始终是大盘在下,小盘在上。 保证三个杆始终是大盘在下,小盘在上 A B C
所谓汉诺塔问题，是古代印度僧侣们玩的一种 游戏。据说游戏结束就意味着世界末日的到来。 游戏的内容是这样的：在一块铜板上竖有三根 杆子，最左边的杆子上按照由大到小的顺序串 有64个金盘，最大的金盘在最下面。游戏要求 利用这三根杆子将左边的杆子上的金盘全部移 到最右边的杆子上。游戏的规则是一次只能移 动一个金盘，而且保证在每次移动金盘的时候 不要将大盘放到小盘上。
age（5）=age（4）＋ （ ） ）＋2 （ ）＋ age（4）=age（3）＋ ）＋2 （ ） （ ）＋ age（3）=age (2）+2 （ ） ） age（2）＝ ）＝age(1）＋ ）＋2 （ ）＝ ）＋ age（1）＝ ）＝10 （ ）＝ 可以用式子表述如下： 可以用式子表述如下： age（n）=10 （n=1） （ ） ） age（n）= age（n-1)+2 （n＞1） （ ） （ ＞ ） 可以看到， 可以看到，当n＞1时，求第 个人的年龄的 ＞ 时 求第n个人的年龄的 公式是相同的。 公式是相同的。因此可以用一个函数来表示 上述关系，下图表示求第5个人年龄的过程 个人年龄的过程。 上述关系，下图表示求第 个人年龄的过程。
评 语
判断题： 1、C语言中所有的函数都能被调用。（×） 2、函数既可以嵌套定义，也可以嵌套调 用。（ × ） 3、函数调用中的实参可以是常量、变量或 表达式。（ ∨） 4、C语言程序的执行在main中开始，并且 语言程序的执行在main中开始，并且 在main中结束。（∨ main中结束。（ ）
f1函数 函数
f2函数 函数
调用f2函数 调用 函数
调用f1函数 调用 函数
直接递归调用
f函数 函数
间接递归调用
f1函数 函数 f2函数 函数
调用f函数 调用 函数
调用f2函数 调用 函数
调用f1函数 调用 函数
显然:从上述例子可以看到，这两种递归调
用都是无终止的自身调用。程序中不 应出现这种无终止的递归调用，而只 能出现有限次数的、有终止的递归调 用，这可以用if语句来控制，当某一 条件成立时不再执行递归调用，这个 条件就是递归终止条件。
函数的递归调用
函数自己直接或间接调用自己 概念： 1、直接递归调用 分类： 2、间接递归调用
｛
1、直接递归调用 long f(int n) {…… f(); ……调用 函数
2、间接递归调用
long f1(int n) {…… f2(); …… } long f2(int m) {…… f1(); …… }
返回
例题一 有5个人坐在一起，问第5个人多 少岁？他说比第4个人大2岁。问第4个人岁 数，他说比第3个人大2岁，问第3个人，又 说比第2个人大2岁。问第2个人，说比第1个 人大2岁。最后问第1个人，他说是10岁。请 问第5个人多大。
分析：要求第5个人的年龄 就必须先知道第4个人的年龄 个人的年龄， 个人的年龄， 分析：要求第5个人的年龄，就必须先知道第4个人的年龄，而 个人的年龄也不知道， 个人的年龄必须先知道第3 第4个人的年龄也不知道，要求第 个人的年龄必须先知道第 个人的年龄也不知道 要求第4个人的年龄必须先知道第 个人的年龄，而第3个人的年龄又取决于第 个人的年龄， 个人的年龄又取决于第2个人的年龄 个人的年龄，而第 个人的年龄又取决于第 个人的年龄，第2 个人的年龄取决于第1个人的年龄 个人的年龄。 个人的年龄取决于第 个人的年龄。而且每一个人的年龄都比其 个人的年龄大2。第一个人的年龄已知， 前1个人的年龄大 。第一个人的年龄已知，根据第一个人的年 个人的年龄大 龄可依次求得第二、 五个人的年龄。 龄可依次求得第二、三、四、五个人的年龄。这就是一个递归问 题。 每一个人的年龄都比其前1个人的年龄大 个人的年龄大2 而每一个人的年龄都比其前 个人的年龄大 就是递归成立的条 递归公式。 也就是递归公式 件，也就是递归公式。