递归

递归

认识递归

1. 自己调用自己
2. 执行一个方法时,就创建一个新的受保护的独立空间(栈空间）
3. 方法的局部变量是独立的,不会相互影响
4. 如果方法中使用的是引用类型变量比如（数组,对象),就会共享该引用类型的数据
5. 递归必须向退出递归的条件逼近,否则就是无限递归出现StackOverflow Error
6. 先进后出，先出后进===========>俄罗斯套娃
7. 当一个方法执行完毕,或者遇到 return,就会返回,遵守谁调用,就将结果返回给谁,同时当方法执行完毕或者返回时,该方法也就执行完毕

递归使用

1. 打印数字
2. 求5的阶乘
3. 斐波那契数
4. 猴子吃桃

public static void main(String[] args) {
   T t = new T();
   //输出什么？ n=2 n=3 n=4
   t.test(4);
   int res = t.factorial(5);
   System.out.println("5 的阶乘 res =" + res);
   int n = 7;
   int result = t1.fibonacci(n);
		if (result != -1) {
			System.out.println("当 n=" + n + " 对应的斐波那契数=" + res);
		}
    int day = 0;
	int peachNum = t1.peach(day);
		if(peachNum != -1) {
			System.out.println("第 " + day + "天有" + peachNum + "个桃子");
		}
	
}

class T {

	public void test(int n) {
		if (n > 2) {
			test(n - 1);
		}
		System.out.println("n=" + n);
	}
       /**
         * 5的阶乘 
	 */
	public int factorial(int n) {
		if (n == 1) {
			return 1;
		} else {
			return factorial(n - 1) * n;
		}
	}
    /**
	 * 请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13...给你一个整数 n，求出它的值是多
	 * 思路分析
	 * 1. 当 n = 1 斐波那契数 是 1
	 * 2. 当 n = 2 斐波那契数 是 1
	 * 3. 当 n >= 3斐波那契数 是前两个数的和
	 * 4. 这里就是一个递归的思路
	 */
	public int fibonacci(int n) {
		if (n >= 1) {
			if (n == 1 || n == 2) {
				return 1;
			} else {
				return fibonacci(n - 1) + fibonacci(n - 2);
			}
		} else {
			System.out.println("要求输入的 n>=1 的整数");
			return -1;
		}
	}
    
    	/**
		 * 猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
		 * 以后每天猴子都吃其中的一半，然后再多吃一个。当到第 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 int peach(int day) {
			if (day == 10) {
                                //第 10 天，只有 1 个桃
				return 1;
			} else if (day >= 1 && day <= 9) {
                                //规则，自己要想
				return (peach(day + 1) + 1) * 2;
			} else {
				System.out.println("day 在 1-10");
				return -1;
			}
		}
}

迷宫问题及八皇后和汉诺塔后续学习