104. 二叉树的最大深度 | 层序遍历 | 遍历 | 子问题 | TypeScript

题目

104. 二叉树的最大深度

解题思路

二叉树题目的递归解法可以分两类思路
第一类是遍历一遍二叉树得出答案
第二类是通过分解问题计算出答案
这两类思路分别对应着 回溯算法核心框架 和 动态规划核心框架。

二叉树的数据结构和算法的关键。
二叉树几乎所有的问题都可以通过前中后来解决，所以需要较大程度上理解并掌握前中后序的遍历。

层序遍历

思路非常的简单，使用队列存储每一层的节点，遍历节点，将节点存入队列，直至所有层被遍历完。

递归

方式一

利用递归，遍历二叉树，最深的深度应当是一个叶子节点的深度，也就是说没有左右孩子的节点的深度
如果统计节点的深度信息？

• 递归会先遍历完一棵子树，然后再去遍历另外一棵树
• 对于一个子树，只要在遍历到这个父节点时统计加一，在离开节点是深度减一，这样就可以保证无误的统计深度
• 实现的保证是无论是哪一棵树，无论是否后代有多少，由于递归的特性，先遍历完一颗树之后再去遍历另外一棵树，这样的方式让当前的树的节点都被遍历，拆分到每一个小树上，当前节点遍历到便加一，离开便减一，遍历子节点时，因为还未离开父节点所在的树，所以统计除了自身的加一外，还有父节点的一，离开时表示当前节点的子树已经遍历完，所以便减去一

注意： 遍历二叉树和使用分解二叉树不要搞混了，遍历时就遍历，不要搞拆分分解

方式二

使用分解子问题的形式统计二叉树的最深深度

• 统计一颗树，最简单的便是分解问题，左子树的最深深度，和右子树的最深深度，两者一比较取大即可
• 分解到所有子树都是这个问题，所以很容易的写出一个递归程序
• 定义递归函数：求出树的最大深度
  • basecase：if(root === null) return 0;
  • 流程定义：求左右子树的最大深度，返回大值并加上自身的深度1

代码

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */


// 使用层序遍历时非常简单的，但是使用递归却并不是那么好理解

// 层序遍历，利用队列存储每一个层，统计每一层即可
function maxDepth1(root: TreeNode | null): number {
    if (root === null) return 0;
    const que: Array<TreeNode> = [];
    let res = 0;
    // 遍历每一层节点，获取最大的深度
    que.push(root);
    while (que.length) {
        res++;
        const size = que.length; // 保留原有一层的长度，后续添加的节点不影响
        for (let i = 0; i < size; i++) {
            let node = que.shift(); // 队列弹出一个节点，将该节点的子节点加入队列中
            if (node.left !== null) que.push(node.left);
            if (node.right !== null) que.push(node.right);
        }
    }
    return res;
};

// 利用递归，遍历二叉树，最深的深度应当是一个叶子节点的深度，也就是说没有左右孩子的节点的深度
// 如果统计节点的深度信息？
// - 递归会先遍历一棵子树，然后再去遍历另外一棵树
// 对于一个子树，只要在遍历到这个节点时统计加一，在离开节点是深度减一，这样就可以保证无误的统计深度
// 实现的保证是无论是哪一棵树，无论是否后代有多少，由于递归的特性，先遍历完一颗树之后再去遍历另外一棵树
// 这样的方式让当前的树的节点都被遍历，拆分到每一个小树上，当前节点遍历到便加一，离开便减一，遍历子节点时，因为还未离开父节点所在的树，所以统计除了自身的加一外，还有父节点的一，这样统计的结果便是正确的。


// ======================遍历二叉树和使用分解二叉树不要搞混了，遍历时就遍历，不要搞拆分====================================
let res: number = 0;
let dep = 0;
function maxDepth2(root: TreeNode | null): number {
    return traverse(root);
};
// 遍历函数，不要做二叉树的拆分，如一些小问题的拆分，不要将两种思想混在一起
function traverse(root: TreeNode | null): number {
    if (root === null) return res;

    dep++; // 遍历到自身就加上一

    // 检查节点，当遇到了叶子节点就统计深度，然后与之前的结果进行比较取值
    if (root.left === null && root.right === null) {
        res = Math.max(dep, res)
        // 注意此时不能直接返回，因为还未减去一，如果需要在这里返回需要减去一
    }

    // 去遍历子节点
    traverse(root.left);
    traverse(root.right);

    dep--; // 离开自身就减去一
    return res;
}

// 利用递归的，除了可以遍历完整的二叉树，检查叶子节点外， 还可以使用分解子问题的形式统计二叉树的最深深度
// 统计一颗树，最简单的便是分解子问题，左子树的最深深度，和右子树的最深深度，两者一比较取最大即可
// 分解到所有子树都是这个问题，所以很容易的写出一个递归程序
// 定义递归的函数时求出树的最大深度，对于每一个子问题都是求左右子树的最大深度
function maxDepth(root: TreeNode | null): number {
    if (root === null) return 0;
    const left = maxDepth(root.left);
    const right = maxDepth(root.right);
    return Math.max(left, right) + 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80