重新认识递归

啥是递归

这里用简单的描述来说就是，递归就是先递，直到不能再递之后再归。
适用场景：。。。。看完文章再说。。。。。

递归究竟长什么样

我记得以前在上生物时有学过一句话，“结构决定功能”,我觉得这里用这句话，再适合不过了。递归的作用正是因为它在计算机的逻辑结构决定了它的功能的。

首先，我们用一个简单的递归过程来看一下递归是怎样的

int digui(int a){
    if (a == 1) return 1;
    else return a + digui2(a-1);
}

这是一个简单的递归过程，就是将1到10的递归相加。
我们从参数为10的函数开始，此时函数在内存中大致有下图来表示（【】内的数字代表函数保存的变量）

【10】
接下来调用参数为9的函数，此时在方法栈大概就是这样的
【10】【9】
下面依次执行后，方法栈中就变成了下图所示
【10】【9】【8】【7】【6】【5】【4】【3】【2】【1】
此时，不用再继续执行函数，开始收缩，就是归的过程
【10】【9】【8】【7】【6】【5】【4】【3】【3】
后续是这样的
【10】【9】【8】【7】【6】【5】【4】【6】
直到最后
【10】【45】
最终返回
【55】

从这个过程中，可以发现，每次进行递归时，它都保存了它当前的变量数值为后续的返回值做准备。这就是递归的最大的特点，保存变量环境。
但是递归保存的不仅仅是变量环境还有程序计数器，下面我们用一个树的深度遍历再来看下递归。

static void f(Node root){
    if (root.left != null) f(root.left);
    System.out.println(root.value);
    if (root.right != null) f(root.right);
}

上面这个函数在进行时，就跟上述的不一样了，单纯的用【4】【2】->【4】【2】【1】->【4】【2】->【4】【2】【3】来模拟是有点问题，因为前两个的执行跟后两个的执行逻辑不一样，这里就有问题了？所以这里要引入一个程序计数器的概念，我们用【4,[0|1|2]】来表示一个函数状态，[0|1|2]就是函数要执行第几行的标志，那么上面的情况就是

【4，1】【2，1】->
【4，1】【2，1】【1，0】->
【4，1】【2，1】【1，1】->
【4，1】【2，1】【1，2】->
【4，1】【2，1】->
【4，1】【2，2】->
【4，1】【2，2】【3，0】

所以这样来表示，就明朗了。
现在明白了递归是什么了，这里再引入循环来模拟递归（毕竟都说循环可以代替递归，而且两者也是有点关系的）
现在已经知道树的深度递归是上面那样，那么就用循环的方式来模拟这个过程
这里先引入一个模拟函数状态类

 static class DiGuiInfo {
        public Node n;
        public int state = 0;//这里代替程序计数器的作用
        DiGuiInfo(Node nn){n = nn;}
    }

Stack<DiGuiInfo> ss = new Stack<>();
DiGuiInfo cur = new DiGuiInfo(root);
do{
    switch(cur.state){
        case 0:
            cur.state++;
            ss.push(cur);
            if(cur.n.left != null){
                cur = new DiGuiInfo(cur.n.left);
                break;
            }
        case 1:
            cur.state++;
            System.out.println(cur.n.value);
            if (cur.n.right != null){
               cur = new DiGuiInfo(cur.n.right);
               break;
            }
       case 2:
            ss.pop();
            if (!ss.empty()){
                cur = ss.peek();
                break;
    }
}while(!ss.empty());

上述就是我对这个过程的模拟（虽然这段代码写得不是很好，请见谅）
所以，这时候我们来对比一下递归的写法和循环的不同之处：
1、写法上，递归函数的写法无疑简单了超多，因为循环中要注意的细节都在函数调用的特质中解决了。
2、空间方面，在前面对递归在内存中的模拟，对比上述循环的写法中，可以发现两者所占的内存是差不多的。
3、时间方面，这个我不敢断言，但以我目前对函数调用的理解，每次切换方法，其实也就是指针的改变，可能还有对应其他的操作吧，但是这个时间在一定范围内是不会有多大影响的。

所以，从上面的比较，我对循环好过递归的说法不是很赞同的。但是也不是全部，在尾递归的模型中，循环确实比递归来得更好，最明显的就是空间复杂度这一点。

对递归的总结

在研究完递归这一过程之后，我想到了如果每次递归调用的不是自身函数，而是其他函数呢，我惊讶的发现我们写的程序其实都是在递归这一状态下运行的。这时候我对递归的理解就不再是调用自身函数这一特点，而是调用任意函数的函数过程本身就是递归）。（刷新了我的编程观）

同时，用递归的写法，其实就是在使用栈模型，（而且还是一个能记录程序运行到哪的栈）那么，有时在写程序时就可以不用栈，而是用递归来写了，这时的递归看起来更像是一种语法糖，还是一个从函数诞生就出现的语法糖呢!

其实在之前我了解到有些语言会有尾递归的优化（这个确实是有必要的）。那时我就想那么其他的递归就不能优化，在研究完上面的这些之后，我才明白一般递归并不是不能优化，而是优化的价值不大，尾递归之所以能优化，那是因为空间复杂度上可以优化，一般递归的空间复杂度是必要的，所以优化嘛，要优化哪里呢，也就没有优化一般递归这一特点了。

最后，递归有什么用呢，写到这里的时候，我觉得我们其实不用去知道递归是什么，其实递归就在我们身边，只是不知道那叫做递归而已。还有一点吧，应该就是简化对栈的使用吧。（这个还没实践过）

谈谈函数式编程中递归

（这里对递归的定义是对任意函数的函数调用过程）
在函数式编程语言中，函数是没有副作用的，所以也就没有全局变量这一概念了，但是，全局变量在编程中，有时是必不可少的，那要怎么解决这个问题呢？所以这里就用递归来解决，因为递归的时候，会有保存变量这一特质，所以这就可以实现全局变量了，这些变量写在最外层就可以了。
同时，在函数式编程语言中，还有一个地方会用到递归，那就是循环的时候，这个原因也很好理解。因为尾递归可以用循环来优化，那么循环就可以用尾递归来写了，之后编译成汇编的时候优化成循环就可以（这不是智障吗）。至于为什么要这样呢？我个人觉得函数式编程语言，它自身在设计的时候，应该就是遵从大道至简的道理吧，函数可以解决的问题，就没必要引入其他的东西（这里感受到函数式编程语言中函数的一种优越感。。。这种优越感还可以从“闭包模拟对象”看出来）。