LeetCode二叉树的最大深度

二叉树的最大深度

1.1 题目描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

1.2 示例

2.1 解题

2.1.1 解题方法：递归进行计算

使用递归，当递归至叶子节点(root == null)，记录递归次数。然后相互比较，找到从根节点到叶节点最多次数递归数即二叉树的最大深度。

Java版解题

/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public int count = 0;	//记录递归次数
    public int _max = 0;	//最大递归次数
    public int maxDepth(TreeNode root) {
        if(root == null)  return count;
        compDep(root,count);
        return _max;
    }

    void compDep(TreeNode root,int count){
        if(root == null){
            if(count > _max) _max=count; 
            return;
        }

        count++;
        compDep(root.left,count);//count记录的为该节点到根节点的路径长度
        compDep(root.right,count);
    }
}

解题结果

官方答案

#### DFS(深度优先) [LeetCode官方解题链接](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/solution/er-cha-shu-de-zui-da-shen-du-by-leetcode-solution/) 如果我们知道了左子树和右子树的最大深度 ll 和 rr，那么该二叉树的最大深度即为 max(l,r) + 1

而左子树和右子树的最大深度又可以以同样的方式进行计算。因此我们可以用「深度优先搜索」的方法来计算二叉树的最大深度。具体而言，计算当前二叉树的最大深度时，可以先递归计算出其左子树和右子树的最大深度，然后在 O(1)O(1) 时间内计算出当前二叉树的最大深度。递归在访问到空节点时退出。
●时间复杂度：O(n)O(n)，其中 nn 为二叉树节点的个数。每个节点在递归中只被遍历一次。
●空间复杂度：O(\textit{height})O(height)，其中 \textit{height}height 表示二叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        } else {
            int leftHeight = maxDepth(root.left);
            int rightHeight = maxDepth(root.right);
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }
}

运行结果

BFS(广度优先)

广度优先基于队列(先进先出)，将所有节点依次入队。当前队列中的元素为同一层的节点，每次拓展下一层的时候，不同于广度优先搜索的每次只从队列里拿出一个节点，我们需要将队列里的所有节点都拿出来进行拓展，这样能保证每次拓展完的时候队列里存放的是当前层的所有节点，即我们是一层一层地进行拓展，最后我们用一个变量ans 来维护拓展的次数，该二叉树的最大深度即为 ans。

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue queue = new LinkedList();
        queue.offer(root);//将根节点入队
        int ans = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();//记录同一层节点个数
            while (size > 0) {
                TreeNode node = queue.poll();//先进先出取出节点
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                size--;
            }
            ans++;
        }
        return ans;
    }
}

复杂度分析

时间复杂度：O(n)，其中 n为二叉树的节点个数。与方法一同样的分析，每个节点只会被访问一次。
空间复杂度：此方法空间的消耗取决于队列存储的元素数量，其在最坏情况下会达到 O(n)。

运行结果