精华内容
下载资源
问答
  • 函数的递归调用

    2019-04-18 17:51:50
    文章目录(一)函数的嵌套调用(二)函数的递归调用 (一)函数的嵌套调用 问题: 输入四个整数,求最大的那个数,使用嵌套调用; 8, 4, 9, 1 #include<iostream> using namespace std; int max1...

    (一)函数的嵌套调用

    问题: 输入四个整数,求最大的那个数,使用嵌套调用;

    8, 4, 9, 1

    #include<iostream>
    using namespace std;
    int max1(int x, int y)//求两个数中的最大数
    {
    	if (x > y)
    		return x;
    	else
    		return y;
    }
    int max2(int a, int b, int c, int d)
    {
    	int m;
    	m = max1(a, b);//此时的m是a和b中较大的那个;
    	m = max1(m, c);//此时的m是a,b,c中较大的那个;
    	m = max1(m ,d);//此时的m是a,b,c,d中最大的那个;
    	return m;
    }
    int main()
    {
    	int a, b, c, d;
    	int max;
    	cin >> a >> b >> c >> d;
    	max=max2(a, b, c, d);
    	cout << max << endl;
    	return 0;
    }
    

    在这里插入图片描述

    分析一下这个算法:
    在main函数里调用max2函数求四个数的最大值,再在max2函数里反复调用max1函数,max1函数的作用就是找两个数中的较大者。

    max2函数的执行过程是这样的:第一次调用max1函数得到的值是a和b中的大者,把它赋值给m;第二次调用max1函数得到m和c中的大者,也就是a,b,c中的最大者,把它赋值给m;第三次调用max1函数得到m和d的大者,也就是a,b,c,d四个数的最大值,把它赋值给m:此时,m的值就是四个数里的最大值;
    这是一种递推的方法,先求两个数的大者,在此基础上再求三个数的大数,再以此为基础,求四个数的最大值;

    max1函数也可以写为一个return语句:

    int max1(int x, int y)
    {
    return x>= y? x : y;
    }

    max2函数也可以改进:

    int max2(int a, int b, int c, int d)
    {
    return max1(max1(max1(a, b), c), d);
    }

    一般的,函数的嵌套调用就是在调用一个函数的过程中,调用另外一个函数;

    如图:
    在这里插入图片描述

    (二)函数的递归调用

    【定义】:在调用函数的过程中又直接或间接的调用该函数本身;

    如图:
    在这里插入图片描述
    显然,这种递归调用是无休止的自身调用,然而算法程序中是不能出现这种情况的;所以,就要写一个递归出口,就是函数满足某一条件时,才执行递归;否则,就不执行;

    看个例题:

    有五个学生坐在一起,问第五个学生几岁,他说比第四个学生大两岁。问第四个学生几岁,他说比第三个学生大两岁。问第三个学生几岁,他说比第二个学生大两岁。问第二个学生几岁,他说比第一个学生大两岁。最后第一个学生他说他10岁,问这五个学生的年龄?

    【思路】:要求第五个学生的年龄,就必须知道第四个学生的年龄,而要求第四个学生的年龄就必须知道第三个学生的年龄,而第三个学生的年龄又取决于第二个学生的年龄,第二个学生的年龄又取决于第一个学生的年龄。而且每个学生的年龄都比前一个大二。即:

    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)

    图解如下:
    在这里插入图片描述
    由图看到,求解过程分为两个阶段;第一个阶段是“回溯”,即age(n)=age(n-1)+2;直到回溯第一个学生的年龄,此时已知age(1)=10;然后就是第二个阶段“递推”,从第一个学生的年龄推出第二个学生的年龄为12岁,从第二个学生的年龄推出第三个学生的年龄为14…一直推出第五个学生的年龄(18岁)为止;
    这里,这个递归不是无限制的执行下去,当age(1)=10时,递归结束;age(1)=10就是递归结束的出口;

    代码如下:

    #include<iostream>
    using namespace std;
    int getage(int n)
    {
    	int c;
    	if (n == 1)//递推出口
    		return c=10;
    	else
    		return c=getage(n - 1) + 2;//递归循环条件;
    }
    int main()
    {
    	int age;
    	int n;//要求的第n个学生的年龄;
    	while (cin >> n&&n) 
    	{
    		age = getage(n);
    		cout <<"该学生的年龄为:"<< age << endl;
    	}
    	return 0;
    }
    

    在这里插入图片描述
    说到这里,相信大家对递归有一定的了解了,那就做个题吧;

    用递推求n!;

    【思路】:5!=4!*5,而4!=3!*4,3!=2!*3,2!=1!*2,1!=1;
    数学公式:

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

    【图解】:
    在这里插入图片描述
    代码如下:

    #include<iostream>
    using namespace std;
    int fun(int n)
    {
    	int c;
    	if (n == 1)
    		return c = 1;//递归出口;
    	else
    		return c = fun(n - 1)*n;
    }
    int main()
    {
    	int n;
    	int num;
    	while (cin >> n&&n)//多次输入当输入等于0时结束输入;
    	{
    		num = fun(n);
    		cout << n;
    		cout << '!'<<'='<<num << endl;
    	}
    	return 0;
    }
    

    在这里插入图片描述
    重要的事情说三遍!!!
    递归出口放在开始!
    递归出口放在开始!
    递归出口放在开始!

    展开全文
  • C语言:函数的递归调用

    千次阅读 多人点赞 2018-07-20 16:14:18
    函数的递归调用:一个函数在它的函数体内,直接或者间接地调用了他本身。 直接递归调用:函数直接调用自身。 间接递归调用:函数间接调用自身。 如下图: 如下图: 防止递归无休止的进...

    函数的递归调用:一个函数在它的函数体内,直接或者间接地调用了他本身。

    直接递归调用:函数直接调用自身。                              间接递归调用:函数间接调用自身。

    如下图:                                                                          如下图:

         防止递归无休止的进行下去,必须在函数内加条件判断,满足条件后就不再做递归调用,然后逐层返回。

    通过一个例子来了解函数的递归调用

    例:求第五个学生的年龄。

    问第五个学生,说他比第四个学生大两岁

    第四个学生说他比第三个学生大两岁

    第三个学生说他比第二个学生大两岁

    第二个学生说他比第一个学生大两岁

    第一个说他10岁

    解:

    可以用如下方法求解

    #include<stdio.h>
    int Age (int n)
    {
    	int tmp;
    	tmp=10;
    	for(int i=1;i<n;i++)
    	{
    		tmp+=2;
    	}
    	return tmp;
    }
    */
    //递归法
    int Age(int n)
    {
    	int x;
    	if(n==1)      //是递归停止的条件,当n=1时停止递归调用
    	{
    		x=10;
    	}
    	else
    	{
    		x=Age(n-1)+2;//调用自身的Age函数
    		return x;
    	}
    		//return (Age(n-1)+2);
    }
    int main()
    {
    	printf("%d\n",Age(5));
    	return 0;
    }

    可知:Age函数被调用了四次。在函数内部的调用,一个函数调用一个函数,直到n为1时为止,所以最后要加的值是8,然后返回最终的值。

    函数的递归调用,就是函数本身调用自己。但是应用递归调用的时候,我们有必要设置一个条件,也就是if语句,目的是能够让这个函数停下来,否则程序将进入到死循环。

    最适合使用递归法解决的问题

    汉诺塔问题(Hanoi)    (见下一篇博客)

    最不适合使用递归法解决的问题

    斐波那契数列(Fibon)

     

     

     

    展开全文
  • 递归调用主要包含两个步骤:递推和回归,我们利用函数的递归调用,分解为相对简单而且可以直接求解的子问题(递推阶段)然后这个子问题的结果逐层进行回带求职,最终求得原来复杂问题的解(回归阶段) 注意: ...

    递归:

    在函数的调用中,有一种特殊的情况,比如一个函数直接的间接的调用自身,称其为函数逇递归调用。

    递归调用有两种形式:

    直接递归:在一个函数中调用自身

    间接递归:在一个函数中调用其他函数,而在其他函数中又调用了本函数

     

    递归调用主要包含两个步骤:递推和回归,我们利用函数的递归调用,分解为相对简单而且可以直接求解的子问题(递推阶段)然后这个子问题的结果逐层进行回带求职,最终求得原来复杂问题的解(回归阶段)

     

    注意:

    递归算法设计简单,但是相比较非递归耗时和占内存

    设计一个正确的递归过程需要注意此过程需满足递归条件,需具备递归结束条件

    最后,通常递归函数常用来计算阶乘、级数、指数运算。

     

    举个例子求数的阶乘

    代码如下:

    #include<iostream>

    using namespace std;

     

    //使用递归调用 打印函数阶乘

     

    int  Fac(int n) {

     

    if (n < 0) {

    cout << "error" << endl;

    return(-1);

    }

    else if (n <= 1) {

     

    return(1);

    }

    else {

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

     

    }

    }

    int main() {

    int Fac(int n);

    int n;

    cout << "please input n:" << endl;

    cin >> n;

    cout << "n!=" << Fac(n) << endl;

     

    system("pause");

    return 0;

     

    }

     

     

     

     

    汉诺塔问题

    问题描述

    相传在古印度圣庙中,有一种被称为汉诺塔(Hanoi)的游戏。该游戏是在一块铜板装置上,有三根杆(编号A、B、C),在A杆自下而上、由大到小按顺序放置金盘(如下图)。游戏的目标:把A杆上的金盘全部移到C杆上,并仍保持原有顺序叠好。操作规则:每次只能移动一个盘子,并且在移动过程中三根杆上都始终保持大盘在下,小盘在上,操作过程中盘子可以置于A、B、C任一杆上

     

    刚好看B站的时候看到李永乐老师说过这个问题。感兴趣的小伙伴可以去看看

    https://www.bilibili.com/video/BV1gJ41177fX/?spm_id_from=333.788.videocard.0

     

    如果一共64层我们按照分析结果一共有1800亿亿步,如果我们一秒钟移动一次,需要5800亿年,宇宙形成到现在只有 138亿年。所以说为了简单点。我们只考虑4层的情况    

    代码如下:             

    #include <iostream>
    using namespace std;

    void hanoi(int N, char A, char B, char C)
    {
        if (N == 1)//在只有一个盘子的情况下,直接从A到C
            cout << A << "-->" << C << endl;
        else
        {//接下按照前面分析的,将前N-1(3)个借助C移到B上
            hanoi(N - 1, A, C, B);
            cout << A << "-->" << B<< endl;//将第n(4)个移到C上
        //对前N-1个递归操作
            hanoi(N - 1, B, A, C);//将对B上的前N-1(3)个借助A,移到C上,结束
        }
    }
     
    int main()
    {
        int N;
        cout << "请输入所要移动盘子的个数:" << endl;
        cin >> N;
        cout << "移动步骤如下:" << endl;
        hanoi(N, 'A', 'B', 'C');
        system("pause");

        return 0;
    }

                   

    结果:

       

    展开全文
  • python函数的递归调用

    2020-11-02 16:07:03
    # ==== 函数的递归调用 ==== def foo(): print("foo...") foo() foo() 递归在某些特定的场景下使用,但是注意不能重复的无限制的对自身进行调用,这会引发异常。Python中默认最大调用自身的次数为1000次: ...

    什么是递归

    递归是一种函数的调用方式。即:自己调用自己。

    # ==== 函数的递归调用 ====
    def foo():
        print("foo...")
        foo()
    foo()
    

    递归在某些特定的场景下使用,但是注意不能重复的无限制的对自身进行调用,这会引发异常。Python中默认最大调用自身的次数为1000次:

    RecursionError: maximum recursion depth exceeded while calling a Python object
    

    递归调用的两种方式

    除开上述的自己调用自己,还有一种调用方式为间接调用自己:

    # ==== 函数的递归调用方式二 ====
    # 遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
    # 寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    def foo():
        print("foo...")
        bar()
    def bar():
        print("bar...")
        foo()
    foo()
    

    在这里插入图片描述

    回溯与递推

    函数递归必须经历两个阶段,他们就是回溯与递推阶段。当函数不断递归调用自身时的阶段被称为回溯阶段,当函数退出递归调用时的阶段被称为递推阶段。

    在这里插入图片描述
    代码表现形式为:

    # ==== 回溯与递推案例 ====
    
    def age(n):
        if n == 1:
            return 18
        return age(n-1) + 10
    
    
    res = age(5)
    print(res)  # 58
    

    应用场景

    著名的汉诺塔游戏:感兴趣的可以搜索一下这个游戏。可以用递归求出游戏结果

    这里不举例汉诺塔游戏,而是举了另一个例子,看代码:

    # 需求,将下面列表中的每一个值取出来并且进行从小到大的排序。返回一个单维列表
    # 遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
    # 寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    l = [10,1.2,[3,345,2.2,[15,[88.6,[78,[89.3,99,[50]]]]]]]
    new_l = []
    
    def my_sort(list1):
        for i in list1:
            if isinstance(i,list):
                my_sort(i)
            else:
                new_l.append(i)
        new_l.sort()
    
    my_sort(l)
    
    print(new_l)
    
    # === 执行结果 ===
    """
    [1.2, 2.2, 3, 10, 15, 50, 78, 88.6, 89.3, 99, 345]
    """
    

    扩展:递归与死循环

    递归和死循环实际上非常相似。但是Python中的递归效率比循环的效率更低,并且循环能完成的事情递归全部都能完成。

    递归与while循环都有共同的特点:必须设置循环体的跳出。

    某些情况下,递归比循环更适合解决问题,就如同上面问年龄的这种情况。

    扩展:如何修改默认递归层次

    import sys
    print(sys.getrecursionlimit()) # 1000 也是Python默认的最大递归层次
    sys.setrecursionlimit(int) # 对于普通的用户来说并不推荐修改该数值。因为这可能导致内存溢出的情况
    

    扩展:尾递归优化

    如果读过生成器底层实现那一小结的朋友应该了解到。Python函数在执行时会创建一个栈帧,并且其中f._back所指就是上层函数的栈帧,栈帧会占据极大的内存空间,它包含了当前函数中的局部/全局命名空间的字典,函数字节码等等等等信息。

    所谓尾递归优化是指:如果一个函数在函数体最后一步调用自身,则无论调用多少次,只会保留一个栈帧信息,这样做能够极大的节省内存空间。因为自己调用自己栈帧都是相同的…

    展开全文
  • Python函数的递归调用

    2020-11-25 15:05:59
    函数的递归调用:是函数嵌套调用的一种特殊形式 具体是指:在调用一个函数的过程当中,又直接或者间接地调用到了本身 Python对递归调用循环调用的次数有限制,为1000次 1.调用的例子: 直接调用本身 def f1(): ...
  • Python-函数的递归调用

    2020-07-23 22:53:10
    即就是说在调用一个函数的过程中,函数内部又调用另一个函数,而函数的递归调用指的是在调用一个函数的过程中又直接或间接地调用该函数本身。 # 直接 def foo(): print('hhh') foo() foo() # 间接 def dar(): ...
  • 函数不仅可以嵌套定义,还可以嵌套调用,即在调用一个函数的过程中,函数内部又调用另一个函数,而函数的递归调用指的是在调用一个函数的过程中又直接或间接地调用该函数本身 例如 在调用f1的过程中,又调用f1,这...
  • c语言:函数的递归调用

    万次阅读 多人点赞 2017-03-11 08:30:53
    而函数中,比较难的一个知识点就是函数的递归调用。 值得注意的是,函数的递归调用在现实工作并不是很常用,但是涉及到算法或者是学校的考试的话,那这个知识点就成了必考的内容。所以,骚年,躲是躲不掉滴~~ 好了...
  • matlab函数的递归调用

    千次阅读 2020-07-28 15:04:08
    matlab函数的递归调用 1、求n的阶乘 函数文件fact.m function f=fact (n) if n<=1 f=1; else f=fact (n-1)*n; end 脚本文件a.m n=input('Please input n='); s=fact (n); disp(s) 2、斐波拉契数列 ...
  • 递归调用、匿名函数、模块一、递归调用1.1函数的递归调用:1.2 递归调用的两个阶段:1.3 总结函数的递归调用二、三元表达式三、匿名函数3.1 定义3.2 用法四、模块4.1 什么是模块?4.2 为何要用模块?4.3 如何使用...
  • C语言函数的递归调用

    2014-03-22 09:54:50
    C语言函数的递归调用 一个函数在它的函数体内调用它自身称为递归调用。这种函数称为递归函数。C语言允许函数的递归调用。在递归调用中,主调函数又是被调函数。执行递归函数将反复调用其自身,每调用一次就进入...
  • 文章logo函数的递归调用一个函数在它的函数体内调用它自身称为递归调用。这种函数称为递归函数。C语言允许函数的递归调用。在递归调用中,主调函数又是被调函数。执行递归函数将反复调用其自身,每调用一次就进入新...
  • c++ 函数的递归调用

    2016-03-05 16:14:33
    在调用一个函数的过程中又出现 直接或间接的调用该函数本身,称为函数的递归调用 例如:代码块在 f() 函数内部 再次调用f() 函数;int f(int x){ int y,z; z=f(y); return (2*z); }具体例子#include using ...
  • 3:函数的递归调用

    2020-04-16 22:27:44
    3:函数的递归调用 编写求n!的程序。要求:编写一个函数实现求出给定的n的值的阶乘。主函数负责确定n的值、调用自定义的函数,并输出计算结果。 输入格式: 输入一个任意整数n的值。 输出格式: 若n=0或n=1,则n!=1;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,004
精华内容 7,601
关键字:

函数的递归调用