方法递归调用
简单地说递归调用就是方法自己调用自己,每次调用时传入不同的变量,递归有助于编程者解决复杂问题,同时可以让代码变得更加简洁。
递归调用执行机制案例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
-------
*/
递归的重要规则
- 执行一个方法时,就创建一个新的受保护的独立空间(栈空间)
- 方法的局部变量是独立的,不会相互影响,比如n变量
- 如果方法中使用的是引用类型变量(比如数组),就会共享该引用类型的数据
- 递归必须向退出递归的条件逼近,否则就是无限递归,出现StackOverflowError,出现栈溢出!“死龟”)
- 当一个方法执行完毕,或者遇到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 个桃子!
---------------------------------
*/