数据结构与算法（Ⅴ）：递归

递归（Recursion）

方法或函数调用自身的方式称为递归调用，调用称为递，返回称为归。递归是一种应用非常广泛的算法（或者编程技巧），DFS深度优先搜索、前中后序二叉树遍历等都要用到递归。

斐波那契数列是典型的递归案例:

F(0) = 0，F(1) = 1，F(n) = F(n-1) + F(n-2)（n >= 2，n∈N+)

public int fib(int n) {
    if (n < 2)
        return n;
    return fib(n - 1) + fib(n - 2);
}

递归优缺点

优点：代码简洁、清晰、可读性高。

缺点：空间复杂度高、有堆栈溢出风险、存在重复计算（如斐波那契数列的递归）、过多的函数调用会耗时较多等问题。

递归条件

递归需要满足的三个条件：

1. 一个问题的解可以分解为几个子问题的解
2. 这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样
3. 存在递归终止条件

如何编写递归代码

写递归代码最关键的是找到如何将大问题分解为小问题的规律，并且基于此写出递推公式，然后再推敲终止条件，最后将递推公式和终止条件翻译成代码。

例如：爬楼梯问题

每次你可以爬 1 或 2 个台阶。有多少种不同的方法可以爬到楼顶 n ?

1. 写出递推公式

实际上，可以根据第一步的走法把所有走法分为两类，第一类是第一步走了 1 个台阶，另一类是第一步走了 2 个台阶。所以 n 个台阶的走法就等于先走 1 阶后，n-1 个台阶的走法，加上先走 2 阶后，n-2 个台阶的走法。用公式表示就是：

f(n) = f(n-1) + f(n-2)

2. 找到终止条件

当有一个台阶时，我们不需要再继续递归，就只有一种走法。所以 f(1) = 1。这个递归终止条件足够吗？我们可以用 n=2，n=3 这样比较小的数试验一下。

n=2 时，f(2) = f(1) + f(0)。如果递归终止条件只有一个 f(1) = 1，那 f(2) 就无法求解了。所以除 f(1) = 1 这一个递归终止条件外，还要有 f(0) = 1，表示走 0 个台阶有一种走法，不过这不符合正常的逻辑思维。所以，可以把 f(2) = 2 作为一种终止条件，表示走 2 个台阶，有两种走法，一步走完或者分两步来走。所以，递归终止条件就是：

f(1) = 1;
f(2) = 2;

3. 将递推公式和终止条件转换成递归代码

int f(int n) {
  if (n == 1) return 1;
  if (n == 2) return 2;
  return f(n-1) + f(n-2);
}

• 编写递归代码的关键是，只要遇到递归，就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。

递归代码模板

Java：

public void recur(int level, int param){
    // 1. 递归中止条件 termimator
    if (level > MAX_LEVEL){
        return;
    }

    // 2. 处理当前层逻辑 process current logic
    process(level, param);

    // 3. 下探到下一层 drill down
    recur(level+1, newParam);

    // 4. 清理当前层（比如全局变量），非必选 restore current status
}

Python：

def recursion(level,param1,param2,...):
    # 1. 递归中止条件 
    if level > MAX_LEVEL:
        return

    # 2. 处理当前层逻辑 
    process(level, data...)

    # 3. 下探到下一层 
    self.recursion(level + 1, p1, ...)

    # 4. 清理当前层

LeetCode实战

22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例：

输入：n = 3
输出：[
       "((()))",
       "(()())",
       "(())()",
       "()(())",
       "()()()"
     ]

// 回溯法
class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> list  = new ArrayList<String>();
        backtrack(list , "", 0, 0, n);
        return list;
    }

    public void backtrack(List<String> list, String str, int open, int close, int max) {
        // termimator
        if (str.length() == max * 2) {
            list.add(str);
            return;
        }
        
        //  process current logic
        
        // drill down
        if (open < max) {
            backtrack(list, str + "(", open + 1, close, max);
        }
        if (close < open) {
            backtrack(list, str + ")", open, close + 1, max);
        }
        
        // restore current status
    }
}

参考文献：

• 算法训练营-覃超
• 数据结构与算法之美-王争
• LeetCode
• 维基百科