JAVA笔记_方法递归调用

方法递归调用

  简单地说递归调用就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂问题，同时可以让代码变得更加简洁。

递归调用执行机制案例1：

 /**
 * @ClassName Recursion01
 * @Description TODO
 * @Author Orange
 * @Date 2021/4/15 8:46
 * @Version 1.0
 **/
public class Recursion01 {
    public static void main(String[] args) {
        int N = 4;
        recursionPrint a = new recursionPrint();    //创建类recursionPrint对象a
        a.test(N);                                  //调用方法test
    }

}

class recursionPrint {
    public void test(int n){
        if(n > 2) {
            test(n - 1);                            //若n不满足条件则继续调用test，并且将 n - 1传给下一个test方法
        }
        System.out.println("n = " + n);
    }
}
/*
程序运行结果：
-------
n = 2
n = 3
n = 4
-------
*/

  程序分析如上图 ↑

递归调用执行机制案例2：

/**
 * @ClassName Recursion01
 * @Description TODO
 * @Author Orange
 * @Date 2021/4/15 8:46
 * @Version 1.0
 **/
public class Recursion01 {
    public static void main(String[] args) {
        int N = 4;

        recursionPrint a = new recursionPrint();    //创建类recursionPrint对象a
        a.test(N);                                  //调用方法test
        int result = a.factorial(N);
        System.out.println(N + " 的阶乘为： " + result);
    }

}

class recursionPrint {
    public void test(int n){
        if(n > 2) {
            test(n - 1);                         //若n不满足条件则继续调用test，并且将 n - 1传给下一个test方法
        }
        System.out.println("n = " + n);
    }

    public int factorial(int n) {
        if(n == 1) {
            return 1;
        }else {
            return factorial(n - 1) * n;
        }
    }
}
/*
程序运行结果：
-------
n = 2
n = 3
n = 4
4 的阶乘为： 24
-------
*/

递归的重要规则

1. 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
2. 方法的局部变量是独立的，不会相互影响，比如n变量
3. 如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据
4. 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError,出现栈溢出！“死龟”）
5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回谁，同时当方法执行完毕或者返回时，该方法也就执行完毕了。

练习题

• 请使用递归的方法求出斐波那契数 0,1,1,2,3,5,8,13…… 给你一个整数n，求出对应的斐波那契额数列

• 猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第10 天时，想再吃时（即还没吃），发现只有1 个桃子了。问题：最初共多少个桃子？

第一题：

/**
 * @ClassName RecursionExercise01
 * @Description TODO
 * @Author Orange
 * @Date 2021/4/15 10:19
 * @Version 1.0
 **/
public class RecursionExercise01 {
    public static void main(String[] args) {
        int N = 10;
        Calculation a = new Calculation();
        for(int i = 1; i <= N; i++) {
            System.out.println("N = " + i + "时，对应的斐波那契数为 " + a.Fibonacci(i));
        }

    }

}

class Calculation {
    public int Fibonacci(int n) {
        int number;
        if(n > 2) {
            number = (Fibonacci((n - 1)) + Fibonacci((n - 2)));
            return number;
        }else {
            return 1;
        }

    }
}
/*
程序运行结果：
N = 1时，对应的斐波那契数为 1
N = 2时，对应的斐波那契数为 1
N = 3时，对应的斐波那契数为 2
N = 4时，对应的斐波那契数为 3
N = 5时，对应的斐波那契数为 5
N = 6时，对应的斐波那契数为 8
N = 7时，对应的斐波那契数为 13
N = 8时，对应的斐波那契数为 21
N = 9时，对应的斐波那契数为 34
N = 10时，对应的斐波那契数为 55
*/

第二题：

/**
 * @ClassName RecursionExercise02
 * @Description TODO
 * @Author Orange
 * @Date 2021/4/15 13:41
 * @Version 1.0
 **/

 /*
猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
以后每天猴子都吃其中的一半，然后再多吃一个。当到第10 天时，
想再吃时（即还没吃），发现只有1 个桃子了。问题：最初共多少个桃子？
思路分析（逆推）
1. day = 10 时有1 个桃子
2. day = 9 时有(day10 + 1) * 2 = 4
3. day = 8 时有(day9 + 1) * 2 = 10
4. 规律就是前一天的桃子= (后一天的桃子+ 1) *2
5. 递归
*/

public class RecursionExercise02 {
    public static void main(String[] args) {
        int num = 1;                                        //最后一天剩余桃子的数量
        int days = 10;                                      //吃桃子花费的天数

        peach a = new peach();

        int SUM = a.peachNum(num, days);                    //SUM为桃子的总数，调用 peachNum()方法，并传递 num和 days
        System.out.println("总共有 " + SUM + " 个桃子！");

        System.out.println("==具体某一天猴子剩余的桃子数量情况==");
        for(int i = 1; i <= days; i++) {
            System.out.println("第 " + i + "天 ， 这个猴子还有 " + a.hspPeachNum(i) + " 个桃子！");

        }
    }
}
class peach {
    public int peachNum(int num,int days) {                 //返回桃子总数（即这个猴子还没下手之前桃子的数量）
        if(days > 1) {
            return peachNum((num + 1) * 2, days - 1);
        }else
            return num;
    }

    public int hspPeachNum(int days) {                      //打印输出对应第几天剩下多少个桃子
        if(days == 10){
            return 1;
        }else if(days >= 1 && days <= 9) {
            return (hspPeachNum(days + 1) + 1) * 2;
        }
    }
}

 /*
程序运行结果：
---------------------------------
总共有 1534 个桃子！
==具体某一天猴子剩余的桃子数量情况==
第 1天 ， 这个猴子还有 1534 个桃子！
第 2天 ， 这个猴子还有 766 个桃子！
第 3天 ， 这个猴子还有 382 个桃子！
第 4天 ， 这个猴子还有 190 个桃子！
第 5天 ， 这个猴子还有 94 个桃子！
第 6天 ， 这个猴子还有 46 个桃子！
第 7天 ， 这个猴子还有 22 个桃子！
第 8天 ， 这个猴子还有 10 个桃子！
第 9天 ， 这个猴子还有 4 个桃子！
第 10天 ， 这个猴子还有 1 个桃子！
---------------------------------
*/

递归调用的经典案例（迷宫案例）：