1 递归(Recursion)
- 递归:函数(方法)直接或间接调用自身。是一种常用的编程技巧
- 函数递归调用时,栈空间的变化
public static void main(String[] args) {
sum(4);
}
private static int sum(int n) {
if (n <= 1) return n;
return n + sum(n - 1);
}
3. 递归时,每次方法调用,都会新建一个栈帧对该方法中变量进行保存,因此随着递归的深度越深,会消耗大量的栈空间。而空间复杂度为某个方法临时占用存储空间大小,而栈空间是可以循环利用的,因此计算递归的空间复杂度时,应该着重观察递归方法同一时间最大能占用多大的栈空间,也就是主要应观察递归深度
4. 递归调用的空间复杂度 = 递归深度 * 每次调用所需的辅助空间
5. 如果递归调用没有终止,将会一直消耗栈空间,最终导致栈内存溢出(Stack Overflow)
6. 所以必需要有一个明确的结束递归的条件,也叫作边界条件、递归基
7. 注意:使用递归不是为了求得最优解,是为了简化解决问题的思路,代码会更加简洁。递归求出来的很有可能不是最优解,也有可能是最优解
2 递归的基本思想
- 拆解问题
- 把规模大的问题变成规模较小的同类型问题
- 规模较小的问题又不断变成规模更小的问题
- 规模小到一定程度可以直接得出它的解
- 求解
- 由最小规模问题的解得出较大规模问题的解
- 由较大规模问题的解不断得出规模更大问题的解
- 最后得出原来问题的解
- 凡是可以利用上述思想解决问题的,都可以尝试使用递归
- 很多链表、二叉树相关的问题都可以使用递归来解决
- 因为链表、二叉树本身就是递归的结构(链表中包含链表,二叉树中包含二叉树)
3 递归的使用套路
- 先明确要编写的递归函数的功能
- 明确原问题与子问题的关系,也就是寻找f(n) 与 f(n – 1)的关系
- 明确递归基(边界条件)
- 思考问题规模小到什么程度可以直接得出解,从而得到递归基
4 练习1 – 斐波那契数列
- fib0:时间复杂度O(2^n),空间复杂度O(n)
//1. 明确递归函数应该做什么:此处递归函数应该想得到第n个斐波那契数
int fib0(int n) {
//3. 明确递归基:当n<=2 时,可以直接得出解,所以n<=2时,应直接返回解1
if (n <= 2) return 1;
//2. 明确f(n)与f(n-1)之间关系:发现f(n) = f(n - 1) + f(n - 2)
return fib0(n - 1) + fib0(n - 2);
}
- fib1:记忆化,时间复杂度:O(n),空间复杂度:O(n)
//用数组存放计算过的结果,避免重复计算
int fib1(int n) {
if (n <= 2) return 1;
int[] array = new int[n + 1];
array[1] = array[2] = 1;
return fib1(n, array);
}
int fib1(int n, int[] array) {
if (array[n] == 0) {
array[n] = fib1(n - 1, array) + fib1(n - 2, array);
}
return array[n];
}
- fib2:去除递归调用,改为"自底向上”的计算过程,时间复杂度:O(n),空间复杂度:O(n)
int fib2(int n) {
if (n <= 2) return 1;
int[] array = new int[n + 1];
array[1] = array[2] = 1;
for (int i = 3; i <= n; i++) {
array[i] = array[i - 1] + array[i - 2];
}
return array[n];
}
- fib3:发现每次运算只需要用到数组中的 2 个元素,所以可以使用滚动数组来优化,O(n),空间复杂度:O(1)
int fib3(int n) {
if (n <= 2) return 1;
int[] array = new int[2];
array[0] = array[1] = 1;
for (int i = 3; i <= n; i++) {
//可以发现,下面表达式中,三个数组元素的下标是不断变化的,对于n=3,第一个下标为1,第二个下标为0,第三个下标为1
//对于n=4,原来下标为0的会变为1,原来下标为1的会变为0
//这就是滚动数组,可以使用一个表达式,每次将数组的下标+1,来存放新数据,效果就类似为数组元素赋值,当值满了,再从头开始赋值
array[i % 2] = array[(i - 1) % 2] + array[(i - 2) % 2];
}
return array[n % 2];
}
- fib4:位运算取代模运算
int fib4(int n) {
if (n <= 2) return 1;
int[] array = new int[2];
array[0] = array[1] = 1;
for (int i = 3; i <= n; i++) {
array[i & 1] = array[(i - 1) & 1] + array[(i - 2) & 1];
}
return array[n & 1];
}
- fib5:去掉数组,使用两个变量替代
- fib6:斐波那契数列恰好有线性代数解法,使用特征方程求解,时间复杂度、空间复杂度取决于 pow 函数(至少可以低至O(logn) )
5 练习2 – 上楼梯(跳台阶)
- 楼梯有 n 阶台阶,上楼可以一步上 1 阶,也可以一步上 2 阶,走完 n 阶台阶共有多少种不同的走法
- 假设 n 阶台阶有 f(n) 种走法,第 1 步有 2 种走法
- 如果上 1 阶,那就还剩 n – 1 阶,共 f(n – 1) 种走法
- 如果上 2 阶,那就还剩 n – 2 阶,共 f(n – 2) 种走法
- 所以 f(n) = f(n – 1) + f(n – 2)
- 假设 n 阶台阶有 f(n) 种走法,第 1 步有 2 种走法
- climbStairs
static int climbStairs(int n) {
if (n <= 2) return n;
return climbStairs(n - 1) + climbStairs(n - 2);
}
- climbStairs1:斐波那契数列几乎一样,因此优化思路也是一致的
static int climbStairs1(int n) {
if (n <= 2) return n;
int first = 1;
int second = 2;
int next = 0;
for(int i=3;i<=n;i++) {
next = first+second;
first = second;
second = next;
}
return next;
}
6 练习3 – 汉诺塔(Hanoi)
- 编程实现把 A 的 n 个盘子移动到 C(盘子编号是 [1, n] )
- 每次只能移动1个盘子
- 大盘子只能放在小盘子下面
- 思路
- 将 n – 1 个盘子从 A 移动到 B
- 将编号为 n 的盘子从 A 移动到 C
- 将 n – 1 个盘子从 B 移动到 C
- 步骤 ① ③ 明显是个递归调用
- Hanoi:时间复杂度O(2^n),空间复杂度O(n)
package com.mj;
public class Hanoi {
public static void main(String[] args) {
new Hanoi().hanoi(3, "A", "B", "C");
}
// 1. 明确递归函数功能:将n个盘子,以p2作为中间的柱子,从p1移动到p3
void hanoi(int n, String p1, String p2, String p3) {
// 3. 明确递归基:当n为1时,只需直接挪动第1号盘子,从p1到p3即可
if (n == 1) {
move(n, p1, p3);
return;
}
// 2. 寻找f(n) 与 f(n – 1)的关系,
// a. 挪动n个盘子,从p1到p3,就是先挪动n-1个盘子从p1到p2
// b. 然后将第n号(注意不是n个)盘子,从p1挪到p3
// c. 最后将n-1个盘子,从p2挪到p3
hanoi(n - 1, p1, p3, p2);
move(n, p1, p3);
hanoi(n - 1, p2, p1, p3);
}
// T(n) = 2 * [2 * T(n - 2) + O(1)] + O(1)
// T(n) = 2^2 * [2 * T(n - 3) + O(1)] + 2 * O(1) + O(1)
// T(n) = 2^3 * T(n - 3) + (2^2 + 2^1 + 2^0) * O(1)
// T(n) = 2^(n - 1) * O(1) + (2^(n-2) + ... + 2^2 + 2^1 + 2^0) * O(1)
// T(n) = [2^(n - 1)+ 2^(n-2) + ... + 2^2 + 2^1 + 2^0] * O(1)
// T(n) = (2^n - 1) * O(1)
// 将第 no 号盘子从 from 移动到 to
static void move(int no, String from, String to) {
System.out.println("将" + no + "号盘子从" + from + "移动到" + to);
}
}
7 递归转非递归
- 递归调用的过程中,会将每一次调用的参数、局部变量都保存在了对应的栈帧(Stack Frame)中
- 因此可以自己维护一个栈,来保存参数、局部变量。递归100%可以转换成非递归。但复杂度不会得到优化
- 在某些时候,也可以重复使用一组相同的变量来保存每个栈帧的内容,复杂度降为O(1)
- Test
package com.mj;
import java.util.Stack;
public class Test {
public static void main(String[] args) {
log(5);
System.out.println("----------------------------------");
logFrame(5);
System.out.println("----------------------------------");
logI(5);
}
static void log(int n) {
if (n < 1)
return;
log(n - 1);
int v = n + 10;
System.out.println(v);
}
static class Frame {
int n;
Frame(int n) {
this.n = n;
}
}
static void logFrame(int n) {
Stack<Frame> frames = new Stack<>();
// 对递归代码前的代码,模拟入栈
for (int i = n; i >= 1; i--) {
// 我理解因为是模拟递归中栈帧的创建,所以自定义的Frame中,只要保存递归代码之前的局部变量(n)即可,递归代码之后的局部变量(v),一定是可以通过之前的局部变量获取到的
frames.push(new Frame(i));
}
// 对递归代码后的代码,模拟出栈
while (!frames.isEmpty()) {
Frame frame = frames.pop();
int v = frame.n + 10;
System.out.println(v);
}
}
// 只用i一个变量,存放栈帧中的局部变量,但要注意,访问i的顺序,需要和出栈的顺序相同,空间复杂度从 O(n)降到了 O(1)
static void logI(int n) {
// 直接模拟出栈的过程,栈帧中局部变保存在i中
for (int i = 1; i <= n; i++) {
System.out.println(i + 10);
}
}
}
8 尾调用(Tail Call)
- 尾调用指一个函数的最后一个动作是调用函数
- 如果最后一个动作是调用自身,称为尾递归(Tail Recursion),尾递归是尾调用的特殊情况
- 下面代码不是尾调用
//因为它最后1个动作是乘法
int factorial(int n){
if(n<=1) return n;
return n*factorial(n-1);
}
8.1 尾调用优化
- 一些编译器能对尾调用进行优化,以达到节省栈空间的目的
- 尾调用优化也叫做尾调用消除
- 优化后,不必为末尾的方法调用,重新创建栈帧,而是直接对其当前所在方法的栈帧进行改造后,使用当前方法栈帧
- 尾调用优化让位于尾位置的函数调用跟 goto 语句性能一样高
- 尾调用优化,会节省大量栈空间
- 尾递归的优化要比尾调用的优化容易很多
- 因为递归方法需要的栈空间与原方法所需栈空间完全相同,不需要调整栈帧大小
- Java虚拟机(JVM)只会对尾递归进行优化,但不会对尾调用进行优化
- 平时的递归代码可以考虑尽量使用尾递归的形式
- 为什么非尾调用无法优化
- 例如方法a中调用方法b
- 如果b不是尾调用,那么b后面还会用到b之前定义的局部变量
- 如果此时进行了优化,那么会导致b后面代码无法再访问到b之前的局部变量值,因为该值已被b中的变量覆盖
8.2 递归改造为尾递归
- 太过难想,只给出例子,证明确实能改造
package com.mj;
public class TailCall {
public static void main(String[] args) {
System.out.println(facttorial(4));
}
/**
* 1 * 2 * 3 * 4 * ... * (n - 1) * n
*
* @param n
* @return
*/
static int facttorial(int n) {
return facttorial(n, 1);
}
static int facttorial(int n, int result) {
if (n <= 1)
return result;
return facttorial(n - 1, result * n);
}
static int facttorial1(int n) {
if (n <= 1)
return n;
return n * facttorial(n - 1);
}
}