递归的基础详解

递归是一种非常广泛的算法，也可以说是编程技巧。
简单来说呢，递归就是把一个复杂的问题，去分解为很多字子问题，这些子问题逻辑都是一样的，但是数据不一样，然后子问题求出答案后，触发了归的条件，进行合并求得最后的答案。
例如在电影院，在不看票和地面的情况下怎么求得自己在第几排呢。
1.你先问你前面的人他在第几排就行，你在她后面+1就是你自己的排数。
2.前面的人也要问他前面的人在第几排，他在他前面的人的排数+1就是他的排数。
…
这样只要最后一个是第1排的，触发“归”的条件，然后进行合并，1+1+1+1+…1 = n这个就是你的排数。
用递归公式总结出来就是

f(n)=f(n-1)+1
你是 n ，然后去问上一层n-1
n-1层的再去问他上一层,n-1-1
…
这样直至问到了第一层，第一层是1，触发了归的条件，告诉他上一次他是1
1的上一层是2，再把2告诉给了2的上一层
…
这样就能求出n是在第几排了

代码显示：

public class Myrecursion {
    public static void main(String[] args) {
        int a = f(5);
        System.out.println("a是第"+a+"排");
    }
    public static int f(int n ){
        if (n==1) {
            System.out.println("我是第"+n+"排");
            return 1;
        };
        System.out.println("我是第"+n+"排");
        return f(n-1)+1;
    }
    }

递归需要满足条件

一、一个问题的解可以分解为几个字问题的解

子问题 就是数据规模更小的问题，例如自己在那一排，可以分解为前一排的人在那一排这样的问题。

二、这个大问题跟分解后的子问题，除了数据规模不一样，求解思路是完全一样

你在那一排，你前一排的人在哪一排，这两个问题是一样的。

三、存在递归终止条件

第一排的人不需要继续询问任何人，也就是说f(1) =1 这就是递归的终止条件。

如何编写递归代码

编写递归代码最重要的就是找到如何将大问题化为小问题的规律，并且基于此写出递推公式，再找到 终止条件，最后把递归公式和终止条件转为代码即可。
例如有N个台阶，每次可以走1个台阶或者2个台阶，请问这n个台阶可以有几种走法。
实际上可以分为两类，一类是走1步，另一类是走2步，所以n个台阶就是等于先走1个台阶后，n-1个台阶的走法+先走2个台阶后，n-2的走法。
公式就是

f(n) = f(n-1)+f(n-2)

有了公式后剩下的就是终止条件了
f(1) =1；剩下一个台阶的时候只有一种走法
f(2)=2；剩下两个台阶的时候有两种走法

    public static int d(int n){
        if (n==1) return 1;
        if (n==2) return 2;
        System.out.println("n:"+n);
        return d(n-1)+d(n-2);
    }

台阶问题的递归可以用以上图表示，当System.out.println(“n:”+n);输出n的时候，会从左遍历这棵树。
例如f(6)
会有以下输出

会调用f(6)，f(6)调用f(5),f(4),f(5)调用(f4),f(3),f(4)调用f(3),f(2)之类的，如同上图。
然后输出的时候会进行遍历这棵树，因为f(1),f(2)直接输出，所以不会展示出来。

遇到递归代码，我们只需要把它想想成为一种递归公式就行，不需要想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。
当面对一个问题分解为多个问题的时候，递归代码没那么好理解，当你想一层一层调用循环去思考的时候，就容易被绕进去。这种重复的时候人脑并不适用于思考，这是计算机擅长的事。
那怎样才是正确的思考呢：
如果一个问题A可以分解为若干个子问题B\C\D，你可以假设子问题B\C\D是已经解决好了的，在此思考如何解决A。你只需要思考问题A于与子问题B\C\D两层之间的关系即可，不需要思考B\C\D跟他们下层的关系。

递归代码需要注意的事

递归需要警惕堆栈溢出

函数调用会使用栈来保存临时变量，每调用一个函数，都会将临时变量封装为栈帧压入内存栈，等函数执行完毕才会释放出栈。系统栈或者虚拟机栈空间一般不大，如果递归求的数据规模很大，调用层次很多，一直压入栈，就会有堆栈溢出的风险。

那么如何防止栈溢出呢
可以设置调用一定深度后，就不继续递归了，而是抛出异常。
例如

if (depth > 1000) throw exception;

递归需要警惕重复计算

例如在爬楼梯的例子里，计算f(5)需要计算f(4)和f(3)，而计算f(4)需要计算f(3),所以f(3)就被重复计算了很多次，这就是重复计算问题

为了避免重复计算，可以通过散列表进行保存已经求过的解。调用f（k）的时候，先冲散列表查询是否已经求解过，如果求解过了，就不需要重复计算了。

    public static int d(int n){
        if (n==1) return 1;
        if (n==2) return 2;
        Map<Integer,Integer> hasSolvedList = new HashMap<Integer,Integer>();
        //System.out.println(n);
        if (hasSolvedList.containsKey(n)){
            return hasSolvedList.get(n);
        }
        System.out.println("n"+n);
        int ret =  d(n-1)+d(n-2);
        hasSolvedList.put(n,ret);
        return ret;
    }

递归代码改写非递归代码

递归代码有利有弊，利是递归代码的表达能力很强，写起来很简洁，弊是空间复杂度高，有堆栈溢出的风险、存在重复计算、过多的函数调用耗时多等问题。
下面看看如何改写递归代码为非递归
第一个例子

    public static int f1(int n){
        int ret =1;
        for (int i=2;i<=n;i++){
            ret = ret+1;
        }
        return ret;
    }

第二个例子

    public static int d1(int n){
        if (n==1) return 1;
        if (n==2) return 2;
        int ret =0;
        int pre = 2;
        int prepre = 1;
        for (int i=3; i<=n;i++){
            ret = pre+prepre;
            prepre = pre;
            pre = ret;
        }
        return ret;
    }

这种思路将递归改成了非递归，本质上没有改变，只是增加了实现的复杂度。