精华内容
下载资源
问答
  • %92数列化归为线性递归数列的常见技巧.pdf
  • 为什么你学不会递归?告别递归,谈谈我的经验

    万次阅读 多人点赞 2019-10-27 16:01:40
    可能很多人在大一的时候,就已经接触了递归了,不过,我敢保证很多人初学者刚开始接触递归的时候,是一脸懵逼的,我当初也是,给我的感觉就是,递归太神奇了! 可能也有一大部分人知道递归,也能看的懂递归,但在...

    可能很多人在大一的时候,就已经接触了递归了,不过,我敢保证很多人初学者刚开始接触递归的时候,是一脸懵逼的,我当初也是,给我的感觉就是,递归太神奇了!

    可能也有一大部分人知道递归,也能看的懂递归,但在实际做题过程中,却不知道怎么使用,有时候还容易被递归给搞晕。也有好几个人来问我有没有快速掌握递归的捷径啊。说实话,哪来那么多捷径啊,不过,我还是想写一篇文章,谈谈我的一些经验,或许,能够给你带来一些帮助。

    为了兼顾初学者,我会从最简单的题讲起!

    递归的三大要素

    第一要素:明确你这个函数想要干什么

    对于递归,我觉得很重要的一个事就是,这个函数的功能是什么,他要完成什么样的一件事,而这个,是完全由你自己来定义的。也就是说,我们先不管函数里面的代码什么,而是要先明白,你这个函数是要用来干什么。

    例如,我定义了一个函数

    // 算 n 的阶乘(假设n不为0)
    int f(int n){
        
    }
    

    这个函数的功能是算 n 的阶乘。好了,我们已经定义了一个函数,并且定义了它的功能是什么,接下来我们看第二要素。

    第二要素:寻找递归结束条件

    所谓递归,就是会在函数内部代码中,调用这个函数本身,所以,我们必须要找出递归的结束条件,不然的话,会一直调用自己,进入无底洞。也就是说,我们需要找出当参数为啥时,递归结束,之后直接把结果返回,请注意,这个时候我们必须能根据这个参数的值,能够直接知道函数的结果是什么。

    例如,上面那个例子,当 n = 1 时,那你应该能够直接知道 f(n) 是啥吧?此时,f(1) = 1。完善我们函数内部的代码,把第二要素加进代码里面,如下

    // 算 n 的阶乘(假设n不为0)
    int f(int n){
        if(n == 1){
            return 1;
        }
    }
    

    有人可能会说,当 n = 2 时,那我们可以直接知道 f(n) 等于多少啊,那我可以把 n = 2 作为递归的结束条件吗?

    当然可以,只要你觉得参数是什么时,你能够直接知道函数的结果,那么你就可以把这个参数作为结束的条件,所以下面这段代码也是可以的。

    // 算 n 的阶乘(假设n>=2)
    int f(int n){
        if(n == 2){
            return 2;
        }
    }
    

    注意我代码里面写的注释,假设 n >= 2,因为如果 n = 1时,会被漏掉,当 n <= 2时,f(n) = n,所以为了更加严谨,我们可以写成这样:

    // 算 n 的阶乘(假设n不为0)
    int f(int n){
        if(n <= 2){
            return n;
        }
    }
    

    第三要素:找出函数的等价关系式

    第三要素就是,我们要不断缩小参数的范围,缩小之后,我们可以通过一些辅助的变量或者操作,使原函数的结果不变。

    例如,f(n) 这个范围比较大,我们可以让 f(n) = n * f(n-1)。这样,范围就由 n 变成了 n-1 了,范围变小了,并且为了原函数f(n) 不变,我们需要让 f(n-1) 乘以 n。

    说白了,就是要找到原函数的一个等价关系式,f(n) 的等价关系式为 n * f(n-1),即

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

    这个等价关系式的寻找,可以说是最难的一步了,如果你不大懂也没关系,因为你不是天才,你还需要多接触几道题,我会在接下来的文章中,找 10 道递归题,让你慢慢熟悉起来

    找出了这个等价,继续完善我们的代码,我们把这个等价式写进函数里。如下:

    // 算 n 的阶乘(假设n不为0)
    int f(int n){
        if(n <= 2){
            return n;
        }
        // 把 f(n) 的等价操作写进去
        return f(n-1) * n;
    }
    

    至此,递归三要素已经都写进代码里了,所以这个 f(n) 功能的内部代码我们已经写好了。

    这就是递归最重要的三要素,每次做递归的时候,你就强迫自己试着去寻找这三个要素。

    还是不懂?没关系,我再按照这个模式讲一些题。

    有些有点小基础的可能觉得我写的太简单了,没耐心看?少侠,请继续看,我下面还会讲如何优化递归。当然,大佬请随意,可以直接拉动最下面留言给我一些建议,万分感谢!

    案例1:斐波那契数列

    斐波那契数列的是这样一个数列:1、1、2、3、5、8、13、21、34…,即第一项 f(1) = 1,第二项 f(2) = 1…,第 n 项目为 f(n) = f(n-1) + f(n-2)。求第 n 项的值是多少。

    1、第一递归函数功能

    假设 f(n) 的功能是求第 n 项的值,代码如下:

    int f(int n){
        
    }
    

    2、找出递归结束的条件

    显然,当 n = 1 或者 n = 2 ,我们可以轻易着知道结果 f(1) = f(2) = 1。所以递归结束条件可以为 n <= 2 时,f(n= = 1。代码如下:

    int f(int n){
        if(n <= 2){
            return 1;
        }
    }
    

    第三要素:找出函数的等价关系式

    题目已经把等价关系式给我们了,所以我们很容易就能够知道 f(n) = f(n-1) + f(n-2)。我说过,等价关系式是最难找的一个,而这个题目却把关系式给我们了,这也太容易,好吧,我这是为了兼顾几乎零基础的读者。

    所以最终代码如下:

    int f(int n){
        // 1.先写递归结束条件
        if(n <= 2){
            return 1;
        }
        // 2.接着写等价关系式
        return f(n-1) + f(n - 2);
    }
    

    搞定,是不是很简单?

    零基础的可能还是不大懂,没关系,之后慢慢按照这个模式练习!好吧,有大佬可能在吐槽太简单了。

    案例2:小青蛙跳台阶

    一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

    1、第一递归函数功能

    假设 f(n) 的功能是求青蛙跳上一个n级的台阶总共有多少种跳法,代码如下:

    int f(int n){
        
    }
    

    2、找出递归结束的条件

    我说了,求递归结束的条件,你直接把 n 压缩到很小很小就行了,因为 n 越小,我们就越容易直观着算出 f(n) 的多少,所以当 n = 1时,你知道 f(1) 为多少吧?够直观吧?即 f(1) = 1。代码如下:

    int f(int n){
        if(n == 1){
            return 1;
        }
    }
    

    第三要素:找出函数的等价关系式

    每次跳的时候,小青蛙可以跳一个台阶,也可以跳两个台阶,也就是说,每次跳的时候,小青蛙有两种跳法。

    第一种跳法:第一次我跳了一个台阶,那么还剩下n-1个台阶还没跳,剩下的n-1个台阶的跳法有f(n-1)种。

    第二种跳法:第一次跳了两个台阶,那么还剩下n-2个台阶还没,剩下的n-2个台阶的跳法有f(n-2)种。

    所以,小青蛙的全部跳法就是这两种跳法之和了,即 f(n) = f(n-1) + f(n-2)。至此,等价关系式就求出来了。于是写出代码:

    int f(int n){
        if(n == 1){
            return 1;
        }
        ruturn f(n-1) + f(n-2);
    }
    

    大家觉得上面的代码对不对?

    答是不大对,当 n = 2 时,显然会有 f(2) = f(1) + f(0)。我们知道,f(0) = 0,按道理是递归结束,不用继续往下调用的,但我们上面的代码逻辑中,会继续调用 f(0) = f(-1) + f(-2)。这会导致无限调用,进入死循环

    这也是我要和你们说的,关于递归结束条件是否够严谨问题,有很多人在使用递归的时候,由于结束条件不够严谨,导致出现死循环。也就是说,当我们在第二步找出了一个递归结束条件的时候,可以把结束条件写进代码,然后进行第三步,但是请注意,当我们第三步找出等价函数之后,还得再返回去第二步,根据第三步函数的调用关系,会不会出现一些漏掉的结束条件。就像上面,f(n-2)这个函数的调用,有可能出现 f(0) 的情况,导致死循环,所以我们把它补上。代码如下:

    int f(int n){
        //f(0) = 0,f(1) = 1,f(2) = 2等价于 n<=2时,f(n) = n。
        if(n <= 2){
            return n;
        }
        ruturn f(n-1) + f(n-2);
    }
    

    有人可能会说,我不知道我的结束条件有没有漏掉怎么办?别怕,多练几道就知道怎么办了。

    看到这里有人可能要吐槽了,这两道题也太容易了吧??能不能被这么敷衍。少侠,别走啊,下面出道难一点的。

    下面其实也不难了,就比上面的题目难一点点而已,特别是第三步等价的寻找。

    案例3:反转单链表。

    反转单链表。例如链表为:1->2->3->4。反转后为 4->3->2->1

    链表的节点定义如下:

    class Node{
        int date;
        Node next;
    }
    

    虽然是 Java语言,但就算你没学过 Java,我觉得也是影响不大,能看懂。

    还是老套路,三要素一步一步来。

    1、定义递归函数功能

    假设函数 reverseList(head) 的功能是反转但链表,其中 head 表示链表的头节点。代码如下:

    Node reverseList(Node head){
        
    }
    

    2. 寻找结束条件

    当链表只有一个节点,或者如果是空表的话,你应该知道结果吧?直接啥也不用干,直接把 head 返回呗。代码如下:

    Node reverseList(Node head){
        if(head == null || head.next == null){
            return head;
        }
    }
    

    3. 寻找等价关系

    这个的等价关系不像 n 是个数值那样,比较容易寻找。但是我告诉你,它的等价条件中,一定是范围不断在缩小,对于链表来说,就是链表的节点个数不断在变小,所以,如果你实在找不出,你就先对 reverseList(head.next) 递归走一遍,看看结果是咋样的。例如链表节点如下

    我们就缩小范围,先对 2->3->4递归下试试,即代码如下

    Node reverseList(Node head){
        if(head == null || head.next == null){
            return head;
        }
        // 我们先把递归的结果保存起来,先不返回,因为我们还不清楚这样递归是对还是错。,
        Node newList = reverseList(head.next);
    }
    

    我们在第一步的时候,就已经定义了 reverseLis t函数的功能可以把一个单链表反转,所以,我们对 2->3->4反转之后的结果应该是这样:

    我们把 2->3->4 递归成 4->3->2。不过,1 这个节点我们并没有去碰它,所以 1 的 next 节点仍然是连接这 2。

    接下来呢?该怎么办?

    其实,接下来就简单了,我们接下来只需要把节点 2 的 next 指向 1,然后把 1 的 next 指向 null,不就行了?,即通过改变 newList 链表之后的结果如下:

    也就是说,reverseList(head) 等价于 ** reverseList(head.next)** + 改变一下1,2两个节点的指向。好了,等价关系找出来了,代码如下(有详细的解释):

    //用递归的方法反转链表
    public static Node reverseList2(Node head){
        // 1.递归结束条件
        if (head == null || head.next == null) {
                 return head;
             }
             // 递归反转 子链表
             Node newList = reverseList2(head.next);
             // 改变 1,2节点的指向。
             // 通过 head.next获取节点2
             Node t1  = head.next;
             // 让 2 的 next 指向 2
             t1.next = head;
             // 1 的 next 指向 null.
            head.next = null;
            // 把调整之后的链表返回。
            return newList;
        }
    
    

    这道题的第三步看的很懵?正常,因为你做的太少了,可能没有想到还可以这样,多练几道就可以了。但是,我希望通过这三道题,给了你以后用递归做题时的一些思路,你以后做题可以按照我这个模式去想。通过一篇文章是不可能掌握递归的,还得多练,我相信,只要你认真看我的这篇文章,多看几次,一定能找到一些思路!!

    我已经强调了好多次,多练几道了,所以呢,后面我也会找大概 10 道递归的练习题供大家学习,不过,我找的可能会有一定的难度。不会像今天这样,比较简单,所以呢,初学者还得自己多去找题练练,相信我,掌握了递归,你的思维抽象能力会更强!

    接下来我讲讲有关递归的一些优化。

    有关递归的一些优化思路

    1. 考虑是否重复计算

    告诉你吧,如果你使用递归的时候不进行优化,是有非常非常非常多的子问题被重复计算的。

    啥是子问题? f(n-1),f(n-2)…就是 f(n) 的子问题了。

    例如对于案例2那道题,f(n) = f(n-1) + f(n-2)。递归调用的状态图如下:

    (img-adCaaEyJ-1572163241563)(https://user-gold-cdn.xitu.io/2019/3/12/169722f31645ef25?w=729&h=444&f=png&s=88214)]

    看到没有,递归计算的时候,重复计算了两次 f(5),五次 f(4)。。。。这是非常恐怖的,n 越大,重复计算的就越多,所以我们必须进行优化。

    如何优化?一般我们可以把我们计算的结果保证起来,例如把 f(4) 的计算结果保证起来,当再次要计算 f(4) 的时候,我们先判断一下,之前是否计算过,如果计算过,直接把 f(4) 的结果取出来就可以了,没有计算过的话,再递归计算。

    用什么保存呢?可以用数组或者 HashMap 保存,我们用数组来保存把,把 n 作为我们的数组下标,f(n) 作为值,例如 arr[n] = f(n)。f(n) 还没有计算过的时候,我们让 arr[n] 等于一个特殊值,例如 arr[n] = -1。

    当我们要判断的时候,如果 arr[n] = -1,则证明 f(n) 没有计算过,否则, f(n) 就已经计算过了,且 f(n) = arr[n]。直接把值取出来就行了。代码如下:

    // 我们实现假定 arr 数组已经初始化好的了。
    int f(int n){
        if(n <= 1){
            return n;
        }
        //先判断有没计算过
        if(arr[n] != -1){
            //计算过,直接返回
            return arr[n];
        }else{
            // 没有计算过,递归计算,并且把结果保存到 arr数组里
            arr[n] = f(n-1) + f(n-1);
            reutrn arr[n];
        }
    }
    

    也就是说,使用递归的时候,必要
    须要考虑有没有重复计算,如果重复计算了,一定要把计算过的状态保存起来。

    2. 考虑是否可以自底向上

    对于递归的问题,我们一般都是从上往下递归的,直到递归到最底,再一层一层着把值返回。

    不过,有时候当 n 比较大的时候,例如当 n = 10000 时,那么必须要往下递归10000层直到 n <=1 才将结果慢慢返回,如果n太大的话,可能栈空间会不够用。

    对于这种情况,其实我们是可以考虑自底向上的做法的。例如我知道

    f(1) = 1;

    f(2) = 2;

    那么我们就可以推出 f(3) = f(2) + f(1) = 3。从而可以推出f(4),f(5)等直到f(n)。因此,我们可以考虑使用自底向上的方法来取代递归,代码如下:

    public int f(int n) {
           if(n <= 2)
               return n;
           int f1 = 1;
           int f2 = 2;
           int sum = 0;
    
           for (int i = 3; i <= n; i++) {
               sum = f1 + f2;
               f1 = f2;
               f2 = sum;
           }
           return sum;
       }
    

    这种方法,其实也被称之为递推

    最后总结

    其实,递归不一定总是从上往下,也是有很多是从下往上的,例如 n = 1 开始,一直递归到 n = 1000,例如一些排序组合。对于这种从下往上的,也是有对应的优化技巧,不过,我就先不写了,后面再慢慢写。这篇文章写了很久了,脖子有点受不了了,,,,颈椎病?害怕。。。。

    说实话,对于递归这种比较抽象的思想,要把他讲明白,特别是讲给初学者听,还是挺难的,这也是我这篇文章用了很长时间的原因,不过,只要能让你们看完,有所收获,我觉得值得!有些人可能觉得讲的有点简单,没事,我后面会找一些不怎么简单的题。最后如果觉得不错,还请给我转发 or 点赞一波!

    另外,推荐一份计算机类书单,只为让大家更加方便找到自己想要的书籍,目前已经收集了几百本了,贡献给需要的人,地址:GitHub 6K,一份覆喊各类编程书籍的书单下载

    这里帅地也整理了一些不错的算法/计算机基础的资料,送给大家:

    翻遍全网,计网、操作系统、计组相关视频被我找到了

    还有一位朋友整理的设计模式资料

    字节跳动总结的设计模式 PDF 火了,完整版开放下载!

    还有一份很不错的算法笔记

    两个月斩获 70k star,前字节大神刷题笔记

    最后,献上我备战校招的思维导图 + 提升内功的 PDF 吧

    九大思维导图助你拿到心仪的 offer

    在这里插入图片描述

    原创 PDF 助你提升基础内容,里面也有我的个人经历

    在这里插入图片描述

    下载链接:https://pan.baidu.com/s/1thH7vqBEosgRrESTUcFL2Q 密码:9x30

    如果觉得有帮助,也要记得来个赞啊,只收藏不点赞都是刷流氓,嘻嘻

    展开全文
  • 递归 (1)概念:函数自己调用自己 (2)问题存在:容易出现死递归,是循环的递归下去,内存不够就报错:栈溢出 //1.直接调用自己 function foo1(){ foo1(); } foo1();//2.间接调用自己 ...

    递归

    (1)概念:函数自己调用自己

    (2)问题存在:容易出现死递归,是循环的递归下去,内存不够就报错:栈溢出
    //1.直接调用自己
    function foo1(){
        foo1();
    }
    foo1();
    //2.间接调用自己
    function foo2(){
        foo3();
    }
    function foo3(){
        foo4();
    }
    function foo4(){
        foo2();
    }
    foo2();

    栈结构
    特点:先入后出
    function f1(){
        f2();
        console.log('f1 finish');
    }
    function f2(){
        f3();
        console.log('f2 finish');
    }
    function f3(){
        console.log('f3 finish');
    }
    f1();//f3 finish     f2 finish     f1 finish
    
    //将函数调用称为调用栈


    (3)递归要实现需要解决两个问题
    1> 停止的条件(解决栈溢出)
    2> 如何调用自己

    (4) 化归的思想(转化为已归纳好的办法):
    对问题进行变形、转化,转换成已经解决的问题,然后直接调用解决好的方法即可。
    所谓的递归其实就是化归。

    (5)如何写递归?
    1> 假设这个问题已经解决,即使写一个空函数也假设已经解决
    2> 根据规律(可能要写两到三次),写出化归的表达式,即递归体
    3> 确定临界条件

    案例:求1,3,5,7,...第n项的值,从0开始
    //1> 假设问题已经解决,肯定需要一个函数,带有一个参数,返回一个结果
    function foo(n){  }
    //2> 要求第n项,根据规律就是 第n-1项 + 2
    就是要求 第n-1项,即 foo(n-1) 就是结果
    因此得到函数体(递归体)
    function foo(n){ 
        return foo(n-1) + 2;
    }
    //3> 确定临界条件,就是在第0项的时候,值为1
    function foo(n){ 
        if(n==0) return 1;
        return foo(n-1) + 2;
    }



    /*
    * 练习1:求1,2,4,8,16, ...第n项的值,从0开始
    * */
    /*1.假设问题已解决,需要一个带参的函数,有返回值*/
    function foo(n){
        /*3.临界条件:第0项时值为1*/
        if(n==0) return 1;
        /*2.规律是第n-1项乘以2*/
        return foo(n-1)*2;
    }
    /*
    * 练习2:求1到n的和
    * */
    function foo2(n){
        if(n==1) return 1;
        return foo2(n-1)+n;
    }
    
    /*
    * 练习3:fibonacci数列,求第n项
    * */
    function foo3(n){
        if( n==1 || n==2 ) return 1;
        return foo3(n-1)+foo3(n-2);
    }
    
    /*
    * 练习4:求阶乘
    * */
    function foo4(n){
        if(n==1) return 1;
        return foo4(n-1)*n;
    }
    
    /*
    * 练习5:求幂,就是n的m次方
    * */
    function foo5(n,m){
        if(m==0) return 1;
        return foo5(n,m-1)*n;
    }






    展开全文
  • 递归与尾递归

    2017-09-13 15:59:23
    一句话理解递归与尾递归  递归就是普通涵数的调用,消耗资源  尾递归就是最后一个调用自已,中间不需要处理数据,所以资源消耗层面很少。  这就象迭代器的好处。  编程很复杂,编程也很简单。简单的逻辑,...

           一句话理解递归与尾递归

          递归就是普通涵数的调用,消耗资源

          尾递归就是最后一个调用自已,中间不需要处理数据,所以资源消耗层面很少。

          这就象迭代器的好处。

           编程很复杂,编程也很简单。简单的逻辑,通过代码组织,就可以变成复杂程序或者系统。以前学物理的时候,老师就说考试的物理题其过程是相当复杂的(简单的就没有必要考了)。解题方法众多,分解法即是一个行之有效的方式。复杂的过程经过分解,会变成简单的定理。如同螺丝,轮胎,玻璃都很简单,却能组合而成复杂的汽车。

    编程也类似,核心哲学甚至简单得令人发指,其一是指针,其二是递归。深入理解者两个概念,很多复杂的系统或者设计,都会化繁为简,一目了然。

    递归

    递归,一个函数在内部调用自己,就是递归。递归在生活中也很常见,例如我们的眼睛,你看对方的眼睛,对方的眼睛里面有你,而那里面那个你又有她,无限循环。再比如,当你拿着一面镜子,对着另外一面镜子的时候,就会发现镜子之中有你手指的镜子,等等。

    12903486_211n.jpg
    12903486_211n.jpg

    尾递归

    函数中可以调用自己成为递归,也可以在末尾调用别的函数。如果一个函数里的最后一个动作是一个函数调用的情形:即这个调用的返回值直接被当前函数返回的情形。这样的调用为尾调用。如果是尾调用自己,即为尾递归

    尾递归是一种形式, 这种形式表达出的概念可以被某些编译器优化. 尾递归的特殊形式决定了这种递归代码在执行过程中是可以不需要回溯的(通常的递归都是需要回溯的). 如果编译器针对尾递归形式的递归代码作了这种优化, 就可能把原本需要线性复杂度栈内存空间的执行过程用常数复杂度的空间完成.

    尾递归通常用于实现以下重复的计算。而一般的语言却不支持尾递归,也就是并没有被优化。例如java, python。它们使用循环迭代来达到同样的效果。

    阶乘计算

    解释递归最常用的例子就是阶乘算法,下面使用 PythonElixirScheme分别实现常用的递归算法。

    class Factorial(object):
        @classmethod
        def recursion(cls, n):
            if n == 1:
                return 1
            return n * cls.recursion(n - 1)
    
    Factorial.recursion(5)  # 输出 120

    魔法书(SICP)中简单的演示了这个调用过程:

    recursion(5)
    5 * recursion(4)
    5 * (4 * recursion(3))
    5 * (4 * (3 * recursion(2)))
    5 * (4 * (3 * (2 * recursion(1))))
    5 * (4 * (3 * (2 * 1)))
    5 * (4 * (3 * 2))
    5 * (4 * 6)
    5 * 24
    120

    函数调用之后,会继续调用自身,并在栈里堆积内存。scheme的解法也很简单:

    #lang scheme
    
    (define (recursion n)
      (if (= n 1)
          1
          (* n (recursion (- n 1)))))
    
    (recursion 5) ; 输出 120

    同样,elixir也很容易实现:

    defmodule Factorial do
        def recursion(n) when n == 1 do
            1
        end
    
        def recursion(n) do
            n * recursion(n-1)
        end
    end
    
    IO.puts Factorial.recursion(5) # 输出 120

    上述是递归调用,并不是尾递归,如果使用尾递归,python代码如下:

    class Factorial(object):
    
        @classmethod
        def tail_recursion(cls, n, acc=1):
            if n == 1:
                return acc
            return cls.tail_recursion(n - 1, n * acc)
    
    Factorial.tail_recursion(5)

    尾递归的调用过程大致是

    tail_recursion(5, 1)
    tail_recursion(4, 20)
    tail_recursion(3, 60)
    tail_recursion(2, 120)
    tail_recursion(1, 120)
    120

    编译器会根据尾递归的方式,进行优化,使得递归调用的时候并不会向线性递归那样堆积内存。就和循环迭代的效果一样。这样也是函数式编程语言处理迭代的问题。

    尾递归优化主要是对栈内存空间的优化, 这个优化是O(n)到O(1)的; 至于时间的优化, 其实是由于对空间的优化导致内存分配的工作减少所产生的, 是一个常数优化, 不会带来质的变化。

    那么看看scheme的实现方式

    (define (tail-recursion n acc)
      (if (= n 1)
          acc
          (tail-recursion (- n 1) (* n acc))))
    
    (tail-recursion 5 1)

    看了两个例子,尾递归还是很好理解。形式上盘的就是最后一个return的时候,是单纯的返回一个函数调用,还是返回函数计算。即

    • 尾递归返回 return cls.tail_recursion(n - 1, n * acc) 只返回纯函数
    • 普通递归返回 return n * cls.recursion(n - 1) 返回函数和别的表达式运算

    函数式语言基本上都支持尾递归,用来做迭代功能,下面是elixir的例子

    defmodule Factorial do
        def tail_recursion(n, acc) when n == 1 do
            acc
        end
    
        def tail_recursion(n, acc \\ 1) do
            tail_recursion(n-1, n * acc)
        end 
    end
    
    IO.puts Factorial.tail_recursion(5)

    迭代与递归

    函数式编程语言,通常没有其他语言所谓的循环关键字。需要迭代的时候,可以用递归实现。最初也比较难理解递归如何实现?实际上,处理循环的时候,都是通过循环因子控制循环条件,在循环体内进行处理计算。递归也可以这样做,递归的条件终止的条件可以用递归的参数设置。

    下面演示给一个列表,遍历每一个列表的元素,并给每个元素的值翻倍。同样使用三种语言代表:

    class Double(object):
        @classmethod
        def recursion(cls, lst):
            if not lst:
                return []
            else:
                head, tail = lst.pop(0), lst
                return [2 * head] + cls.recursion(lst)
    
        @classmethod
        def tail_recursion(cls, lst, new_lst=[]):
            if not lst:
                return new_lst
            else:
                head, tail = lst.pop(0), lst
                new_lst.append(2 * head)
                return cls.tail_recursion(tail, new_lst)
    
    
    Double.recursion([1, 2, 3, 4, 5])
    Double.tail_recursion([1, 2, 3, 4, 5])

    Scheme

    (define (recursion lst)
      (if (null? lst)
          `()
          (cons (* 2 (car lst)) (recursion (cdr lst)))))
    
    
    (define (tail-recursion lst new-lst)
      (if (null? lst)
          new-lst
          (tail-recursion (cdr lst) (append new-lst (list (* 2 (car lst)))))))
    
    (recursion (list 1 2 3 4 5))
    (tail-recursion (list 1 2 3 4 5) `())

    Elixir

    defmodule Double do
        def recurssion([head|tail]) do
            [2 * head | recurssion(tail)]
        end
    
        def recurssion([]) do
            []
        end
    
        def tail_recursion([head|tail], new_list) do
            new_list = new_list ++ [2 * head]
            tail_recursion(tail, new_list)
        end
    
        def tail_recursion([], new_list) do
            new_list
        end
    end
    
    Double.recurssion([1, 2, 3, 4, 5])
    Double.tail_recursion([1, 2, 3, 4, 5], [])

    了解递归和尾递归之后,另外一个需要了解就是并不是每个语言都支持尾递归。上述的 python就不支持。Python使用尾递归,在数据量稍大的时候会溢出。此外,像 Scheme和Elixir这些语言则很好的支持。当需要在遍历的时候写逻辑,可以抽象出逻辑为一个个函数,更有利于代码的模块化和复用。

    总结一下,普通递归过程是函数调用,涉及返回地址、函数参数、寄存器值等压栈等,而尾递归压栈操作并无必要,不会有中间结果需要缓存。通常是语言层面是否支持,编译器或解释器中进行优化。

     



    作者:人世间
    链接:http://www.jianshu.com/p/1f69cb4525ec
    來源:简书

    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 

    展开全文
  • 递归

    2019-11-10 13:40:57
    递归函数主要是化归思想 ,将一个复杂的问题简单化,主要用于解决数学中的一些问题居多。 把要解决的问题,归结为已经解决的问题上。 一定要考虑什么时候结束让函数结束,也就是停止递归(一定要有已知条件) 应用:...

    递归函数

    递归函数:函数内部直接或者间接的调用自己
    递归的要求:

    1. 自己调用自己(直接或者间接)
    2. 要有结束条件(出口)
    3. 递归函数主要是化归思想 ,将一个复杂的问题简单化,主要用于解决数学中的一些问题居多。

    把要解决的问题,归结为已经解决的问题上。
    一定要考虑什么时候结束让函数结束,也就是停止递归(一定要有已知条件)

    应用:获取按钮下标的两种方式

    由于点击事件是异步的,当点击按钮的时候for循环早就执行完了,i也自增完毕,此前只是循环了10次函数声明,所以点击按钮每个函数里的i永远指向同一个全局i,值是10.

    <button>按钮1</button>
    <button>按钮2</button>
    <button>按钮3</button>
    <button>按钮4</button>
    <button>按钮5</button>
    <button>按钮6</button>
    <button>按钮7</button>
    <button>按钮8</button>
    <button>按钮9</button>
    <button>按钮10</button>
    
    // 获取按钮下标
    
    var buttons = document.querySelectorAll("button")
    // 方式一:
    // 为对象添加index属性保存下标
    // for (var i = 0; i < buttons.length; i++) {
    //     buttons[i].index = i
    //     buttons[i].onclick = function () {
    //         // console.log("ok");
    //         console.log(this.index);
    
    //     }
    // }
    // 方式二:
    // 闭包
    
    for (var i = 0; i < buttons.length; i++) {
        (function (index) {
            buttons[i].onclick = function () {
                // console.log("ok");
                console.log(index);
            }
        })(i)
    
    
    }
    
    展开全文
  • 方法一:递归 如果 N 等于 1 或等于 2,则返回 1。 否则,通过 Fn=Fn−1+Fn−2F_n =F_{n−1} +F_{n−2}Fn​=Fn−1​+Fn−2​ 调用自身求解问题。 public int fib(int N) { // if (N == 0) return 0; // if (N == 1...
  • 递归与线性表

    2018-05-14 00:49:39
    非常经典的递归模型就是关于汉诺塔问题,在盘子数量很少时、我们可以总结出来一些律,发现这些盘子的移动都有共同点、总是先将n-1个盘子借助于辅助塔先从第n个盘子上挪开、然后将第n个放置指定位置、然后重复这个...
  • 递归与迭代

    2020-02-15 17:09:42
    今天我们来了解一些解题方法,其实递归法和迭代法都是一种数学思想,都是用来解决一些数学问题的,那么他们有什么区别呢? 递归就是从自己本身延伸出去的,是分治法的一种;...递归:先递,后。我们可以把递...
  • 空间复杂度: O(2n)O(2^n)O(2n) 在 n = 5 时的递归树将是这样的: 方法二:记忆化递归 由图可知,在上一种方法中,计算每一步的结果时出现了冗余。 我们可以把每一步的结果存储在 visited 数组之中,每当函数再次被...
  • 递归与回溯

    2019-04-17 11:53:00
    相比于迭代,递归的效率低,但是递归的解决方案简单,源算法逻辑一致性强,使用迭代需要定义一个新的数据结构实现堆栈,迭代应当适用在实时系统。 实例:斐波那契数列使用递归实现: 0,1,1,2,3,5,8, 13...
  • 递归与尾递归(C语言) 原文:递归与尾递归(C语言)【转】 作者:archimedes 出处:http://www.cnblogs.com/archimedes/ 本文版权作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,...
  • 递归 阶乘 let j = (n) => n === 1 ? 1: n * j (n - 1) 层层递推,然后层层返回,就叫递归 j(4) = 4 * j(3) = 4 * (3 * j(2)) = 4 * (3 * (2 * j(1))) = 4 * (3 * (2 * 1)) = 4 * (3 * 2) = 4 * 6 = 24 调用栈 ...
  • 记忆化递归(自顶向下)3.动态规划(自底向下) 1.传统递归 在我前面的文章举例了几个递归案例, 递归案例. 首先来来看第一一个例子,斐波那契数列。原题见链接: 剑指 Offer 10- I. 斐波那契数列 . 斐波那契数列...
  • 标准Java类库中泛型排序所使用的算法,递归实现递归实现
  • &lt;!DOCTYPE html&gt;&lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="utf-8"&gt; &... var arr = [1,23,[3,4,[44,5],66],[454

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,061
精华内容 7,224
关键字:

化归与递归