LeetCode N叉树系列 ～ N 叉树的最大深度

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第4天，点击查看活动详情

题目

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例

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

输入：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, 10^4] 之间

树的遍历：

• 前序遍历：首先访问根节点，然后遍历左节点，再遍历右节点；
• 中序遍历：首先遍历左节点，然后访问根节点，再遍历右节点；
• 后序遍历：首先遍历左节点，然后遍历右节点，再访问根节点；
• 层序遍历：按照从左到右的顺序，逐层遍历各个节点。

在二叉树中，有前、中、后序以及层序可以进行遍历，这些遍历的方法，前、后、层序遍历同样可以运用到N叉树中。至于中序遍历，由于并没有一个明确的标准来定义，其中间点因人而异，故暂不考虑N叉树的中序遍历

将二叉树转化成N叉树，我们只需要将其左右节点的遍历修改为对所有子节点的遍历即可，常规的方式有for循环遍历等。

N 叉树的最大深度

/*
// Definition for a Node.
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;
    }
};
*/

class Solution {
    public int maxDepth(Node root) {
        return maxDepth(root, 0);
    }

    public int maxDepth(Node root, int depth) {
        // 边界判断
        if(null == root){
            return depth;
        }
        
        // 深度 + 1
        depth += 1;

        // 用来记录最大深度
        int max = depth;

        // 遍历所有子节点，找到最大深度
        for(Node node : root.children){
            max = Math.max(max, maxDepth(node, depth));
        }
        
        // 返回结果
        return max;
    }
}

N叉树的层级遍历递归解法

在前面LeetCode N叉树系列 ～ N叉树的层序遍历中，虽然我们也可以得到N叉树的深度，但是使用的是队列的解法，那么我们可不可以像其它两个遍历一样使用递归来完成呢？答案是可以的，我们只需要在最大深度的基础上进行一点小改造即可，利用depth变量来实现层级的区分，然后将相同层级节点加入集合中即可。

扫描二维码关注公众号，回复： 14420270 查看本文章

/*
// Definition for a Node.
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;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();

        levelOrder(root, res, 0);

        return res;
    }

    public void levelOrder(Node root, List<List<Integer>> res, int depth){
        // 边界判断
        if(null == root){
            return;
        }

        // 当前结果集如果小于等于当前深度，则需要加多一层，用于保存当前层级节点
        if(res.size() <= depth){
            res.add(new ArrayList<>());
        }

        // 保存当前层级元素
        res.get(depth++).add(root.val);

        // 遍历子节点
        for(Node node : root.children){
            levelOrder(node, res, depth);
        }
    }
}