LeetCode刷题-N叉树的最大深度

前言说明

算法学习,日常刷题记录。

题目连接

N叉树的最大深度

题目内容

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

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

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

示例1:

图1

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

输出:3

示例2:

图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, 10^4]之间。

分析过程

思路:深度优先搜索,利用递归,若一棵树有n个节点,设maxChildDepth为n个节点中的最大深度,那么这棵树的最大深度是n+1。

第一步

若节点为空,返回0。

第二步

定义最大子节点深度maxChildDepth,初始为0;获取节点的子节点children,遍历子节点children。

第三步

每次遍历时,递归调用自身函数maxDepth,获取每一个子节点的最大深度,定义为childDepth,和当前最大子节点深度maxChildDepth比较,取最大值,更新到最大子节点深度maxChildDepth。

第四步

最后,返回最大子节点深度maxChildDepth加1,即为n叉树的最大深度,结束程序。

解答代码

/*
// Definition for a Node.
class Node {
    public int val;
    public List children;

    public Node() {}

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

    public Node(int _val, List _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public int maxDepth(Node root) {
        // 深度优先搜索,若一棵树有n个节点,设maxChildDepth为n个节点中的最大深度,那么这棵树的最大深度是n+1

        if (root == null) {
            // 若节点为空,返回0
            return 0;
        }

        // 定义最大子节点深度
        int maxChildDepth = 0;

        // 获取节点的子节点
        List children = root.children;

        if (children != null) {
            // 遍历子节点
            for (Node node : children) {
                // 递归调用自身,获取每一个子节点的最大深度
                int childDepth = maxDepth(node);

                // 和当前最大子节点深度比较,取最大值,更新到最大子节点深度
                maxChildDepth = Math.max(maxChildDepth, childDepth);
            }
        }

        // 返回最大子节点深度加1,即为n叉树的最大深度
        return maxChildDepth + 1;
    }
}

提交结果

执行用时1ms,时间击败100.00%的用户,内存消耗38.7MB,空间击败10.62%的用户。

运行结果

延伸分析

但是,题目中并没有给出输入的数组转为N叉树的代码,在LeetCode上刷题时LeetCode后台已经帮你做了转换,但是如果我们要自己写出完整代码,需要自己做转换,思路和之前的数组转二叉树类似,通过队列辅助来实现广度优先搜索,即模拟层序遍历时从上到下从左到右的过程,把数组转换为N叉树,不过这里不同的是,每组子节点由空值分隔,改为遇到空值时才进行队列出列操作。

数组转二叉树,请看文章:LeetCode刷题-我会翻转二叉树,谷歌还要我吗?

完整代码如下:

import java.util.*;

public class Main {

    public static void main(String[] args) {
        // 获取输入结果
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        scanner.close();

        // 处理输入结果
        Integer[] nums;
        if ("[]".equals(str)) {
            // 当数组为空
            nums = null;
        } else {
            // 当数组不为空
            String[] strs = str.split("\\[")[1].split("]")[0].split(",");
            int size = strs.length;
            nums = new Integer[size];
            for (int i = 0; i < size; ++i) {
                if ("null".equals(strs[i])) {
                    nums[i] = null;
                } else {
                    nums[i] = Integer.parseInt(strs[i]);
                }
            }
        }

        // 数组转为N叉树
        Node root = arrayToTreeNode(nums);

        // 获取输出结果
        int result = maxDepth(root);
        System.out.println(result);
    }

    // 数组转为N叉树,层序遍历,分层按照从上到下,从左到右的顺序
    private static Node arrayToTreeNode(Integer[] nums) {
        // 利用队列辅助,N叉树输入按层序遍历序列化表示,每组子节点由空值分隔
        // 例子:[1,null,3,2,4,null,5,6],[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]

        if (nums == null || nums.length == 0) {
            // 若N叉树节点为空,直接返回空
            return null;
        }

        // 数组的开始下标
        int i = 1;

        // 先构造N叉树根节点
        Node root = new Node(nums[0]);

        // 定义当前的N叉树节点,保存临时值
        Node current = null;

        // 定义当前数组的值
        Integer value;

        // 定义队列,层序遍历创建N叉树
        Queue queue = new LinkedList<>();

        // 先把N叉树根节点放进队列最后
        queue.add(root);

        // 遍历数组,构造N叉树
        while (i < nums.length) {
            if (nums[i] == null) {
                // 若节点值为空,下标加1
                ++i;

                // 若节点值为空,队列出列元素,获取当前父节点
                current = queue.poll();
            } else {
                // 获取数组的值,数组下标加1
                value = nums[i++];

                // 创建当前父节点的孩子
                Node node = new Node(value);

                if (current == null) {
                    current = new Node();
                }

                if (current.children == null) {
                    current.children = new ArrayList<>();
                }

                // 当前父节点添加孩子
                current.children.add(node);

                // 把当前父节点的孩子入列
                queue.add(node);
            }
        }

        // 返回N叉树的根节点
        return root;
    }

    private static int maxDepth(Node root) {
        // 深度优先搜索,若一棵树有n个节点,设maxChildDepth为n个节点中的最大深度,那么这棵树的最大深度是n+1

        if (root == null) {
            // 若节点为空,返回0
            return 0;
        }

        // 定义最大子节点深度
        int maxChildDepth = 0;

        // 获取节点的子节点
        List children = root.children;

        if (children != null) {
            // 遍历子节点
            for (Node node : children) {
                // 递归调用自身,获取每一个子节点的最大深度
                int childDepth = maxDepth(node);

                // 和当前最大子节点深度比较,取最大值,更新到最大子节点深度
                maxChildDepth = Math.max(maxChildDepth, childDepth);
            }
        }

        // 返回最大子节点深度加1,即为n叉树的最大深度
        return maxChildDepth + 1;
    }

}

// Definition for a Node.
class Node {
    public int val;
    public List children;

    public Node() {
    }

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

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

其中,arrayToTreeNode方法就是把输入的数组转为N叉树。

完整代码获取:https://github.com/zjhpure/algorithmPractice/blob/master/src/main/java/org/pure/algorithm/maximumDepthOfNAryTree/Main.java

原文链接

原文链接:N叉树的最大深度

你可能感兴趣的:(LeetCode刷题-N叉树的最大深度)