回调函数和递归函数的应用

一.回调函数  

意义:回调函数是一个函数的函数名作为另外一个函数的参数传入，并且执行

目的:执行完一件事后，自动执行另外一个函数的事情。

举例1:

function fn(f){
        console.log("bbb")  //fn1函数名作为fn的参数传入，并执行
         f();
   }
 
 function fn1(){
       console.log("aaa");
  }
        fn(fn1);   //执行完打印bbb后，自动执行打印aaa

　　　　　　结果:  bbb   aaa　　　

举例2: 面对多个封装好的函数时，可以自由选择执行哪一个，不执行哪一个

    function fn1(a,b){
            return a+b;
        }
        function fn2(a,b){
            return a*b;
        }

        function fn(a,b,fn){
            fn(a,b);
        }

       var sum=fn(3,5,fn1);
       var s=fn(3,5,fn2);  
　　　　console.log(sum,s)             结果:  8     15

举例3:  函数的互相调用

 function first(b,c,a){
        setTimeout(function(){
            console.log("红灯")
            b(c,a,b);
        },1000)
    }

    function second(c,a,b){
        setTimeout(function(){
            console.log("绿灯");
            c(a,b,c); 
        },1000)
    }

    function third(a,b,c){
        setTimeout(function(){
            console.log("黄灯");
            a(b,c,a);   
        },1000)
    }

    first(second,third,first);     结果:  红灯  绿灯  黄灯 .........

这种使用方法是有些抽象的，如果不是很理解的，可以观察其中规律，掌握规律后再来研究，方便许多。

二.递归函数

什么是递归函数? 递归函数说简单了就是:  函数自己执行自己

作用:  遍历(适用多层结构)

递归有三类:广度递归    深度递归    时间复杂度

1.广度递归   

  var obj = {
            a: 1,
            b: 2,
            c: {
                a: 3,
                b: 4,
                c: {
                    a: 5,
                    b: 6,
                    c: {
                        a: 7,
                        b: 8,
                        c: {
                            a: 9,
                            b: 10
                        }
                    }
                }
            }
        }

       function fn1(obj){
            for(var prop in obj){
                console.log(prop,obj[prop]);
                if(typeof obj[prop]==="object"){
                    fn1(obj[prop]);
                }
            }
       }                                       结果有些长，这里就不写了，自己打印吧

打印后很清楚的能看到，广度递归就是一层一层的打印。

2.深度递归    

深度递归分为三种，先序遍历， 中序遍历，后序遍历 ，下面看例子(二叉树)

        function createObj(_value){
            var o={};
            o.left=null;
            o.right=null;
            o.value=_value;
            return o;
        }

        var obj=createObj(1);
        obj.left=createObj(2);
        obj.right=createObj(3);
        obj.left.left=createObj(4);
        obj.left.right=createObj(5);
        obj.right.left=createObj(6);
        obj.right.right=createObj(7);   

a.先序遍历

   function showObj(o){
            console.log(o.value);
            if(o.left)showObj(o.left);
            if(o.right) showObj(o.right);
            
        }

        showObj(obj);              结果是:1234567

b.中序遍历

  function showObj(o){
            if(o.left)showObj(o.left);
            console.log(o.value);
            if(o.right) showObj(o.right);
            
        }

        showObj(obj); 结果是:4251637

c.后序遍历

 function showObj(o){
            if(o.left)showObj(o.left);
            if(o.right) showObj(o.right);
            console.log(o.value);
            
        }

        showObj(obj);   结果是:4526731