LeetCode(剑指offer-tree)-面试题55 - I. 二叉树的深度

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

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

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

提示：

节点总数 <= 10000

链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof

树的遍历方式总体分为两类：深度优先搜索（DFS）、广度优先搜索（BFS）；

1. 常见的 DFS ： 先序遍历、中序遍历、后序遍历；
2. 常见的 BFS ： 层序遍历（即按层遍历）。

求树的深度需要遍历树的所有节点，本文将介绍基于 后序遍历（DFS） 和 层序遍历（BFS） 的两种解法。

方法一：后序遍历（DFS）

1. 树的后序遍历 / 深度优先搜索往往利用 递归 或 栈 实现，本文使用递归实现。
2. 关键点： 此树的深度和其左（右）子树的深度之间的关系。显然，此树的深度 等于 左子树的深度 与 右子树的深度 中的 最大值 +1。

算法解析：

1. 终止条件： 当 root​ 为空，说明已越过叶节点，因此返回 深度 0 。
2. 递推工作： 本质上是对树做后序遍历。
   1. 计算节点 root​ 的 左子树的深度 ，即调用 maxDepth(root.left)；
   2. 计算节点 root​ 的 右子树的深度 ，即调用 maxDepth(root.right)；
3. 返回值： 返回 此树的深度 ，即 max(maxDepth(root.left), maxDepth(root.right)) + 1。
   流程图

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
     
public:
    int maxDepth(TreeNode* root) {
     
        if (root == NULL) {
     
            return 0;
        }

        // dfs 递归调用求取每个子树的深度, +1 代表加上跟节点的深度
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

方法二：层序遍历（BFS）

1. 树的层序遍历 / 广度优先搜索往往利用 队列 实现。
2. 关键点： 每遍历一层，则计数器 +1+1 ，直到遍历完成，则可得到树的深度。

算法解析：

1. 特例处理： 当 root​ 为空，直接返回 深度 0。
2. 初始化： 队列 queue （加入根节点 root ），计数器 res = 0。
3. 循环遍历： 当 queue 为空时跳出。
   1. 初始化一个空列表 tmp ，用于临时存储下一层节点；
   2. 遍历队列： 遍历 queue 中的各节点 node ，并将其左子节点和右子节点加入 tmp；
   3. 更新队列： 执行 queue = tmp ，将下一层节点赋值给 queue；
   4. 统计层数： 执行 res += 1 ，代表层数加 1；
4. 返回值： 返回 res 即可。
   流程图

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
     
public:
    int maxDepth(TreeNode* root) {
     
        int treeDepth = 0;
        if (root == NULL) {
     
            return treeDepth;
        }
        queue<TreeNode*> nodes; // 依次更新每层节点数
        queue<TreeNode*> temp; // 临时队列保存tree每层节点
        // 根节点加入队列
        nodes.push(root);
        while(!nodes.empty()) {
     
            // 只要nodes队列中有节点，深度就加一
            treeDepth++;
            queue<TreeNode*>().swap(temp); // temp 队列清空
            int layerNodes = nodes.size();
            for (int i=0; i<layerNodes; i++) {
     
                TreeNode *currentNode = nodes.front();
                nodes.pop();
                // 当前层下一层的节点数
                if (currentNode->left) {
     
                    temp.push(currentNode->left);
                }
                if (currentNode->right){
     
                    temp.push(currentNode->right);
                }
            }
            // 先清空再赋值，temp 赋值给 nodes
            queue<TreeNode*>().swap(nodes);
            nodes = temp;
        }

        return treeDepth;
    }
};