【算法】二叉树的最大深度

【算法】二叉树的最大深度（java）

二叉树的定义

定义是什么，就是每个节点下会有二个节点（左节点和右节点）。用代码定义一个二叉树的一个节点类如下：

class TreeNode {
    //节点值
    int val;
    //左节点
    TreeNode left;
    //右节点
    TreeNode right;

	//构造函数
    TreeNode() { }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

求二叉树的最大深度

想要求一个给定的二叉树的最大深度。思路如下：

递归实现：

1、遍历N叉树根节点下的【子节点数组】，每次遍历一个节点时，都递归调一次方法

2、递归到最下层的节点时，该节点的【子节点数组】将会是一个空列表，这时递归返回该节点的深度为1，然后继续向上递归返回，并把每个节点对应的深度都添加到一个【保存深度的数组】中

3、最后，返回【保存深度的数组】中的最大元素 + 1

代码实现如下：

public int maxND(NTreeNode root) {
    if (root == null) {
        return 0;
    } else if (root.sonTreeNodeList.isEmpty()) {
        return 1;
    }
    //定义一个【保存深度的数组】
    List<Integer> heights = new LinkedList<>();
    //遍历当前节点下的所有子节点
    for (NTreeNode item : root.sonTreeNodeList) {
        //对每一个节点求最大深度
        int depth = maxND(item);
        //把每个节点对应的深度保存在数组中
        heights.add(depth);
    }
    //返回数组中最大的元素 + 1
    return Collections.max(heights) + 1;
}

广度优先算法

思路：

1、先将根节点入队

2、写一个循环，不断取出队列中的节点，每取出一个节点，就累加一次深度。然后遍历当前节点下的所有节点，并将节点依次入队。直到最终队列为空，循环结束

3、然后返回最终的深度

public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    //队列先让根节点入队
    queue.offer(root);
    //最大深度
    int ans = 0;

    //遍历队列中的节点，直到队列为空
    while (!queue.isEmpty()) {
        int size = queue.size();
        //如果队列大小大于0，执行循环
        ans++;
        //遍历该节点的所有节点
        while (size > 0) {
            //先出队一个元素
            TreeNode node = queue.poll();
            size--;
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    return ans;
}