1. 题目

2. 思路

(1) BFS

• 利用队列实现层序遍历，返回层数即可。

(2) DFS

• 利用递归实现前序遍历，返回最大深度即可。

3. 代码

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Test {
    
    
    public static void main(String[] args) {
    
    
    }
}

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) {
    
    
        if (root == null) {
    
    
            return 0;
        }
        int res = 0;
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
    
    
            res++;
            for (int i = queue.size(); i > 0; i--) {
    
    
                Node node = queue.poll();
                for (Node child : node.children) {
    
    
                    queue.offer(child);
                }
            }
        }
        return res;
    }
}

class Solution1 {
    
    
    private int res;
    private int cur;

    public int maxDepth(Node root) {
    
    
        if (root == null) {
    
    
            return 0;
        }
        dfs(root);
        return res;
    }

    private void dfs(Node root) {
    
    
        if (root == null) {
    
    
            return;
        }
        cur++;
        res = Math.max(res, cur);
        for (Node child : root.children) {
    
    
            dfs(child);
        }
        cur--;
    }
}