【算法题】递归求二叉树深度

二叉树的深度算法，是二叉树中比较基础的算法了。对应 LeetCode 第104题。

而后你会发现 LeetCode 后面有些算法题须要用到这个算法的变形，好比第110题、543题。这两道题，若是你知道二叉树深度算法的递归过程，就很容易作出来。

关于二叉树的相关知识，能够看个人这篇文章：数据结构】树的简单分析总结（附js实现）

题目描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例： 给定二叉树 [3,9,20,null,null,15,7]，

3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。
复制代码

注意这里的二叉树是经过 链式存储法 存储的，而不是数组。

1. 递归是什么

在解题以前，咱们先了解下什么是递归（若是你已经掌握，请直接跳过这节）。

那么就开始朗（wang）诵（ba）课本（nian）内容（jing）。

递归分为 “递” 和 “归”。“递” 就是传进去，“归”就是一个函数执行完解决了一个子问题。递归的实现经过不停地将问题分解为子问题，并经过解决子问题，最终解决原问题。

递归的核心在于递归公式，当咱们分析出递归公式后，递归问题其实也就解决了。递归是一种应用普遍的编程技巧，不少地方都要用到它，好比深度优先遍历（本题就用到这个）、二叉树的前中后序遍历。

递归须要知足三个条件：

1. 能够分解为多个子问题；
2. 子问题除了数据规模不一样，求解思路不变；
3. 存在递归终止条件。

递归的特色是代码比较简洁，虽然大多数状况下你都比较难理解递归的每一个过程，由于它不符合人类的思惟习惯，但其实你也没必要去真正了解，你只要知道B和 C 被解决后，能够推导出 A 就行，无需考虑 B 和 C 是如何经过子问题解决的（由于都和前面同样的！）。

其次递归若是太深，可能会致使内存用尽。由于递归的时候要保存许多调用记录，就会维护一个调用栈，当栈太大而超过了可用内存空间，就会发生内存溢出的状况，咱们称之为 堆栈溢出。解决方案有下面 4 种：

1. 递归调用超过必定深度以后，直接报错，再也不递归下去。 深度到底到多少会发生溢出，并不能经过计算得出，另外报错也致使程序没法继续运行下去，因此这个方案虽然确实能够防止内存溢出，并好像没有什么用。
2. 缓存重复计算。 递归可能会重复调用已经求解过的 f(k) 的结果，对于这种状况，就要对 f(k) 进行缓存，通常用哈希表来缓存（js 中能够经过对象实现）。当咱们第二次执行 f(k) 时，直接从缓存中获取便可。
3. 改成非递归代码。 其实就是改成循环的写法。修改后的循环写法本质上也是递归，只是咱们手动地实现了递归栈而已。循环写法代码实现会比递归复杂，并且也不够优雅。
4. 尾递归。 使用的是一种 尾调用优化 的技术，须要看运行环境是否提供这种优化。在支持尾调用优化的状况下，若是函数 A 的 最后一步 调用另外一个函数 B，那进入 B 时，就不会保留 A 的调用记录（好比一些 A 的内部变量），这样就不会产生很长的调用栈，而致使堆栈溢出了。

说到递归，那就不得不提递归的一道经典题目了，那就是“爬楼梯问题”，对应 LeetCode 第70题。

爬楼梯的问题描述是：假设你正在爬楼梯。须要 n （正整数）阶你才能到达楼顶。每次你能够爬 1 或 2 个台阶。你有多少种不一样的方法能够爬到楼顶呢？

首先你能够列出 n = 1，n = 2... 的走法，试着找出规律。

阶	走法	走法总数
1	1	1
2	1 + 1，2	2
3	1 + 2， 1 + 1 + 1， 2 + 1	3

到这里咱们就能够发现一些规律了。那就是 走到第 3 阶的走法为 2 阶 和 1 阶的和。为何会这样呢？咱们就要透过现象发现本质，本质就是，要走到第 n 阶，首先就要先走到 第 n-1 阶，而后再爬一个台阶，或者是先走到 n - 2 阶，而后爬两个台阶。

因此咱们获得这么一个递归公式：f(n) = f(n-1) + f(n - 2)

递归写法：

var climbStairs = function(n) {
    let map = {};
    function f(n) {
        if (n < 3)  return n;
        if (map[n]) return map[n];
        
        let r =  f(n-1) + f(n - 2);
        map[n] = r;
        return r;
    }
    return f(n)
复制代码

由于 f(n) = f(n-1) + f(n-2)。这里的f(n-1)，又由 f(n-2)+f(n-3) 得出。这里的 f(n-2) 被执行了两次，因此就须要缓存 f(n-2) 的结果到 map 对象中，来减小运算时间。

循环写法：

var climbStairs = function(n) {
    if (n < 3) return n;

    let step1 = 1,  // 上上一步
        step2 = 2;  // 上一步

    let tmp;
    for (let i = 3; i <= n; i++) {
        tmp = step2;
        step2 = step1 + step2;
        step1 = tmp;
    }
    return step2;

};
复制代码

2. 问题分析

说完递归后，咱们就来分析题目吧。

首先咱们试着找出递归规律。首先咱们知道，除了叶子节点，二叉树的全部节点都有会有左右子树。那么若是咱们知道左右子树的深度，找出两者之间的最大值，而后再加一，不就是这个二叉树的深度吗？其次以 叶子节点 为根节点的二叉树的高度是 1，咱们就能够根据经过这个做为递归的结束条件。

3. 代码实现

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {number} */
var maxDepth = function(root) {
    function f(node) {
        if (!node) return 0;
        return Math.max(f(node.left), f(node.right)) + 1;
    }
    return f(root);
};
复制代码

这里用到了深度优先遍历，会沿着二叉树从根节点往叶子节点走。另外，由于没有重复计算，因此不须要对结果进行缓存。还有就是，由于没有多余的变量要保存，能够直接把 maxDepth 函数写成递归函数。

4. 扩展：数组存储的二叉树如何求深度？

关于如何用数组存储（顺序存储法）的二叉树，这里就不提了，请看我前面提到的相关文章。

求一个数组表示的二叉树的深度，能够看做求 对应的彻底二叉树的深度。

在此以前，咱们先看看如何求出一个节点个数为 n 的 满二叉树 的深度 k。

深度 k	个数 n
1	1
2	3 (=1+2)
3	7 (=1+2+4)
4	15 (=1+2+4+8)

规律很明显，经过等比数列求和公式化简，咱们获得 k = Math.log2(n+1)，其中 k 为深度，n 为满二叉树的节点个数。那么对于一个彻底二叉树来讲，将 k 向上取整便可：k = Math.ceil( Math.log2(n+1) )。

因此对于一个顺序存储法存储的长度为 n 的二叉树，其高度 k 为：

k = Math.ceil( Math.log2(n+1) )
复制代码

（须要注意的是，这里的数组是从 0 开始存储节点的。）

参考

1. 阮一峰的网络日志——尾调用优化
2. 数据结构与算法之美：10 | 递归：如何用三行代码找到“最终推荐人”？