这是我参与11月更文挑战的第13天，活动详情查看：2021最后一次更文挑战

1.题目

2021年11月21日leetcode的每日一题题目跳转链接在此： 559. N 叉树的最大深度

题目如下：

给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6] 输出：3

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5

提示：

• 树的深度不会超过 1000 。
• 树的节点数目位于 [0, 104] 之间。

给出的多叉树数据结构为：

class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};

2. 解题

首先，题目要求N叉树的最大深度，这道题也很简单，我们可以将问题分解：我需要知道一个节点的最大深度，只需要递归计算出其每个子树的最大深度maxChildDepth，然后再+1就可以了，因此我们可以用深度搜索算法来解这道题：

解法一：深度优先搜索

public int maxDepth(Node root) {
        //递归返回条件，在叶子节的子节点时，当前深度为0，所以返回0；
        if (root == null) {
            return 0;
        }
        //设置一个对象来记录最大值
        int maxChildDepth = 0;
        //逐个遍历子节点，计算所有子节点最大深度
        List<Node> children = root.children;
        for (Node child : children) {
            int childDepth = maxDepth(child);
            maxChildDepth = Math.max(maxChildDepth, childDepth);
        }
        //返回当前深度，当前深度 = 所有子树最大深度+1
        return maxChildDepth + 1;
    }

• 时间复杂度：每个节点访问一次，复杂度为O(n)
• 空间复杂度：递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度为O(height)

解法二：广度优先搜索

public int maxDepth(Node root) {
    if (root == null) {
        return 0;
    }
    //保存当前层的所有节点
    Queue<Node> queue = new LinkedList<Node>();
    //第一层只有root
    queue.offer(root);
    //维护拓展的次数
    int ans = 0;
    while (!queue.isEmpty()) {
        int size = queue.size();
        //循环里，去掉当前这一层的所有节点，再将他们的子节点全放到队列中
        while (size > 0) {
            Node node = queue.poll();
            List<Node> children = node.children;
            for (Node child : children) {
                queue.offer(child);
            }
            size--;
        }
        //当前这一层全部节点都已经经历过，深度加1
        ans++;
    }
    return ans;
}

• 时间复杂度：每个节点访问一次，复杂度为O(n)
• 空间复杂度：此方法空间的消耗取决于队列存储的元素数量，在最坏情况空间复杂度为 O(n)

3. 总结

总的来说，树和图的算法经常会碰到DFS和BFS，大家应该熟练掌握这两种算法。