104.二叉树的最大深度

104.二叉树的最大深度

题目描述：给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

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

示例：给定二叉树  [3, 9, 20, null, null, 15, 7]

返回它的最大深度3。

 

方法一：递归

整棵二叉树的深度等于其左子树深度(leftHeight)和右子树深度(rightHeight),两者中的较大值加1(加1即加上根节点)

max(leftHeight, rightHeight) + 1

而左子树和右子树的最大深度可以以同样的方式进行计算。因此可以先递归计算出其左子树和右子树的最大深度，再求得当

前二叉树的最大深度。递归在访问到空节点时退出。

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) {val = x;}
* }
*/
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;
        }
    }
}

复杂度分析

时间复杂度:O(n)，其中n为二叉树节点的个数。每个节点在递归中只被遍历一次。

空间复杂度:O(height)，其中height表示二叉树的高度。递归函数需要栈空间，栈空间取决于递归的深度，因此空间复杂度等

价于二叉树的高度。

最坏情况下，树是完全不平衡的，例如每个节点只剩下左子节点，递归将会调用n次，此时空间复杂度为O(n)。

最好情况下，树是完全平衡的，树的高度为log(n)，此时时间复杂度为O(log(n)).

方法二：广度优先搜索

对广度优先搜索进行修改，当前广度优先搜索队列里存放的是当前层的所有节点。每次拓展下一层的时候，将队列里所有节

点都拿出来进行拓展。用一个变量count来维护拓展的次数，该二叉树的深度即为result。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int count = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size-- > 0){
                TreeNode temp = queue.poll();
                if(temp.left != null){
                    queue.offer(temp.left);
                }
                if(temp.right != null){
                    queue.offer(temp.right);
                }
            } 
            count++;
        }
        return count;
    }
}

复杂度分析

时间复杂度：O(n)，其中n为二叉树节点的个数，每个节点仅被访问一次。

空间复杂度：此方法空间的消耗取决于队列存储的元素数量，在最坏情况下回达到O(n)，最优情况下为O(1)。