知识改变命运 第六集：递归

1.递归

3.1 生活中的故事

从前有坐山，山上有座庙，庙里有个老和尚给小和尚将故事，讲的就是：
"从前有座山，山上有座庙，庙里有个老和尚给小和尚讲故事，讲的就是：
“从前有座山，山上有座庙…”
“从前有座山……”
"

上面的两个故事有个共同的特征：自身中又包含了自己，该种思想在数学和编程中非常有用，因为有些时候，我们遇到的问题直接并不好解决，但是发现将原问题拆分成其子问题之后，子问题与原问题有相同的解法，等子问题解决之后，原问题就迎刃而解了。

3.2 递归的概念

一个方法在执行过程中调用自身, 就称为 “递归”.
递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式.
例如, 我们求 N!
起始条件: N = 1 的时候, N! 为 1. 这个起始条件相当于递归的结束条件.递归公式: 求 N! , 直接不好求, 可以把问题转换成 N! => N * (N-1)!
递归的必要条件：

1. 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
2. 递归出口
   代码示例:递归求 N 的阶乘

public static void main(String[] args) {
	int n = 5;
	int ret = factor(n);
	System.out.println("ret = " + ret);
}
public static int factor(int n) {
	if (n == 1) {
		return 1;
	}
	return n * factor(n - 1); // factor 调用函数自身
}
// 执行结果
ret = 120

3.2 递归执行过程分析

递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 “方法的执行过程”, 尤其是 “方法执行结束
之后, 回到调用位置继续往下执行”.
代码示例: 递归求 N 的阶乘

public static void main(String[] args) {
	int n = 5;
	int ret = factor(n);
	System.out.println("ret = " + ret);
}
public static int factor(int n) {
	System.out.println("函数开始, n = " + n);
	if (n == 1) {
		System.out.println("函数结束, n = 1 ret = 1");
		return 1;
	}
	int ret = n * factor(n - 1);
	System.out.println("函数结束, n = " + n + " ret = " + ret);
	return ret;
}
// 执行结果
函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret = 120

执行过程图

程序按照序号中标识的 (1) -> (8) 的顺序执行.
关于 “调用栈”
方法调用的时候, 会有一个 “栈” 这样的内存空间描述当前的调用关系. 称为调用栈.
每一次的方法调用就称为一个 “栈帧”, 每个栈帧中包含了这次调用的参数是哪些, 返回到哪里继续执行等信息.
后面我们借助 IDEA 很容易看到调用栈的内容.

下面强调一个错误，不是异常！

3.3 递归练习

代码示例1 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public static void print(int num) {
	if (num > 9) {
		print(num / 10);
	}
	System.out.println(num % 10);
}

代码示例2 递归求 1 + 2 + 3 + … + 10
public static int sum(int num) {
if (num == 1) {
return 1;
}
return num + sum(num - 1);
}
代码示例3 写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回
1+7+2+9，它的和是19

public static int sum(int num) {
	if (num < 10) {
	return num;
	}
	return num % 10 + sum(num / 10);
}

代码示例4 求斐波那契数列的第 N 项
斐波那契数列介绍: https://baike.sogou.com/v267267.htm?
fromTitle=%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97

public static int fib(int n) {
	if (n == 1 || n == 2) {
		return 1;
	}
	return fib(n - 1) + fib(n - 2);
}

当我们求 fib(40) 的时候发现, 程序执行速度极慢. 原因是进行了大量的重复运算.

class Test {
	public static int count = 0; // 这个是类的成员变量. 后面会详细介绍到.
	public static void main(String[] args) {
		System.out.println(fib(40));
		System.out.println(count);
	}
	public static int fib(int n) {
		if (n == 1 || n == 2) {
			return 1;
		}
		if (n == 3) {
			count++;
		}
	return fib(n - 1) + fib(n - 2);
	}
}
// 执行结果
102334155
39088169 // fib(3) 重复执行了 3 千万次.	

可以使用循环的方式来求斐波那契数列问题, 避免出现冗余运算

public static int fib(int n) {
	int last2 = 1;
	int last1 = 1;
	int cur = 0;
	for (int i = 3; i <= n; i++) {
		cur = last1 + last2;
		last2 = last1;
		last1 = cur;
	}
	return cur;
}

此时程序的执行效率大大提高了.
注意：不过上面代码有小问题，当n等于1时候没办法计算。