剑指Offer：[第18天 搜索与回溯算法(中等)]---＞Ⅰ. 二叉树的深度

---

一、题目描述

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

例如：

给定二叉树 [3,9,20,null,null,15,7]，
    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

提示：

节点总数 <= 10000

二、思路分析

注：思路分析中的一些内容和图片参考自力扣各位前辈的题解，感谢他们的无私奉献

思路

求树的深度需要遍历树的所有节点，树的遍历方式总体分为两类：深度优先搜索(DFS)、广度优先搜索(BFS)
常见的DFS：先序遍历、中序遍历、后序遍历
常见的BFS：层序遍历

方法一：后序遍历

树的后序遍历(DFS)往往利用递归或栈实现，本文使用递归实现。
关键点：此树的深度等于左子树的深度与右子树的深度中的最大值+1

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










复杂度分析：
时间复杂度$O(N)$：N为树的节点数量，计算树的深度需要遍历所有节点
空间复杂度$O(N)$：最差情况下(当树退化为链表时)，递归深度可达到N

方法二：中序遍历

树的层序遍历(BFS)通常利用队列实现
关键点：每遍历一层，则计数器+1，直到遍历完成，则可得到树的深度。
算法流程：
①特例处理：当root为空，直接返回深度为0
②初始化：初始化队列queue(加入根节点root)，队首元素下标front=0，队尾插入元素下标rear=1，计数器layer=0
③循环遍历：当queue为空时跳出
----初始化：记录当前层的最后一个结点，同时layer+=1
----遍历队列： 遍历queue中的各节点node，并将其左子节点和右子节点入队queue，在这个过程中更新队列队首元素的下标。
④返回值：返回layer即可
复杂度分析：
时间复杂度$\mathrm{O}(\mathrm{N})$：N为树的节点数量，计算树的深度需要遍历所有节点
空间复杂度$\mathrm{O}(\mathrm{N})$：最差情况下(当树平衡时)，队列queue同时存储N/2个节点

三、整体代码

后序遍历整体代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int max(int a, int b){
    return a > b ? a : b;
}

int maxDepth(struct TreeNode* root){
    if(!root) return 0;
    return max(maxDepth(root->left), maxDepth(root->right))+1;
}

运行，测试通过

中序遍历整体代码如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int maxDepth(struct TreeNode* root){
    if(!root) return 0;

    struct TreeNode* queue[10000];
    //先将root入队
    queue[0] = root;
    int front = 0;
    int rear = 1;
    int layer = 0;

    while(front < rear){
        layer++;  //层数+1
        int rear_tmp = rear;  //记录当前层的最后一个结点
        for(; front<rear_tmp; front++)   //遍历当前层的结点
        {
            //将当前层所有节点的左右孩子入队
            if(queue[front]->left){
                queue[rear++] = queue[front]->left;
            }
            if(queue[front]->right){
                queue[rear++] = queue[front]->right;
            }
        }
    }

    return layer;
}

运行，测试通过