递归

递归求解问题的过程可以分为两步，第一步是“递”，第二步是“归”。

递归的重点是找到递归公式和确定递归终止条件 ，递归算法是一种高效简洁的编程技巧，但是也是一种非常容易引起错误的算法。

递归代码有很多弊端：比如，堆栈溢出、重复计算、函数调用耗时多、空间复杂度高等。

下边结合一个简单的问题理解递归。

有n级台阶，上台阶可以有两种走法，一次走一步，或者一次走两步，问总共有多少步走法。

很容易想出递归的公式：，这样理解：

假设有n级台阶，那么其实可以分为两种走法，第一次走一步的走法，加上第一步走两步的走法，两次之和就是总共有几种走法。

所以推出递归公式如上。

但是需要找出终止条件，显然f(1) = 1，f(0)这种说法并不合适，我们找f(2)也就是还有两级台阶，有两种走法。所以写出下边递归代码：

    public static int cost(int stairs){
        if (stairs == 1){
            return 1;
        }
        if (stairs == 2){
            return 2;
        }

        return cost(stairs -1) + cost(stairs -2);
    }

但是我们仔细思考后发现，这样计算存在大量重复计算的行为。

计算10的时候会计算9和8，但是计算9的时候还要计算8，所以存在重复。

我们进行改造，将计算过的值存在一个表中，表中有计算过的值，就不用计算了。

改进的代码如下：

    /**
     * 将计算的结果保存在表里，防止重复计算
     * @param stairs
     * @return
     */
    public int coastMap(int stairs){
        if (stairs == 1) {
            return 1;
        }

        if (stairs == 2) {
            return 2;
        }

        if (stairsMap.containsKey(stairs)){
            return stairsMap.get(stairs);
        }

        int cost = coastMap(stairs -1) + coastMap(stairs -2);
        stairsMap.put(stairs,cost);
        return cost;
    }

这样就可以大大提升程序性能。

其实这个算法可以继续改进成非递归的操作，因为递归算法的级别通常是n!级，运算量是巨大的，不适合进行大规模运算，我们可以使用正常的算法解决这个问题：

  /**
     * 用正常的方法计算，不用递归
     * @param stairs
     * @return
     */
    public static int coastNrmal(int stairs){
        if (stairs == 1) {
            return 1;
        }

        if (stairs == 2) {
            return 2;
        }
        int res = 0;
        int pre = 2;
        int prepre = 1;
        for (int i = 3 ; i < stairs + 1; i++){
            res = pre + prepre;
            prepre = pre;
            pre = res;
        }
        return res;
    }

每次计算将前几次的结果相加，运算量就很小了。