递归算法

1.什么是递归？

• 什么是递归？
  任何调用自身的函数称之为递归。
• 需要注意的几点
  必须要有终止条件
  每次递归之后，需要将问题简单化
  只考虑很少的几步，剩下的都是规模更小的同类问题

2. 几个经典问题的实现

• 阶乘
• 斐波那契数列
• 汉诺塔
• 青蛙跳台阶

package com.company;

public class Main {


    /**
     * 计算阶乘
     * n!= 1        (n=0)
     * n!=n*(n-1)!  (n>0)
     *
     * @return
     */
    public static int factorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }

    /**
     * 斐波那契数列
     * f(n)=1               (n=1,n=2);
     * f(n)=f(n-1)+f(n-2);  (n>2);
     * @param n
     * @return
     */
    public static int Fibonacci(int n) {
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }
        return Fibonacci(n-1)+Fibonacci(n-2);
    }

    /**
     * 实现汉诺塔：
     * s1：将源柱最上面的（n-1）个盘子搬到辅助柱
     * s2：将第n个盘子从源柱搬到目的柱
     * s3: 将辅助柱上的（n-1）个搬到目的柱子（比原始规模小的一个新的同类问题）
     *
     * @param n
     */
    public static void hanno(int n, String from, String dest, String aux) {
        if (n == 1) {
            System.out.println(from + "---->" + dest);
            return;
        } else {
            /*将源柱最上面的（n-1）个盘子搬到辅助柱*/
            hanno(n - 1, from, aux, dest);
            /*将第n个盘子从源柱搬到目的柱*/
            System.out.println(from + "----->" + dest);
            /*将辅助柱上的（n-1）个搬到目的柱子*/
            hanno(n - 1, aux, dest, from);
        }
    }

    /**
     * 青蛙跳台阶：一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。
     * 求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
     * 分析：如果只有1阶：只用一种跳法：----------------------------------->f(1)=1;
     * 如果有2阶：有两种跳法：第一次跳1阶，再跳1阶；第二种：直接跳2阶---->f(2)=2;
     * 如果是n阶：那么必须先到（n-1）阶或是（n-2）阶------------------->f(n)=f(n-2)+f(n-1);
     */

    public static int frog(int step) {
        if (step == 1) {
            return 1;
        }
        if (step == 2) {
            return 2;
        }
        return frog(step - 1) + frog(step - 2);
    }


    public static void main(String[] args) {
        int frog = frog(120);
        System.out.println("frog = " + frog);
    }

}