力扣104. 二叉树的最大深度

104. 二叉树的最大深度

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

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

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

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

返回它的最大深度 3 。

 思路一：递归

递归计算左右子树的高度，树的高度等于左右子树的最大高度加一

/**
 * 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;
        }
        // 递归计算左右子树的高度，树的高度等于左右子树的最大高度加一
        int leftDep = maxDepth(root.left);
        int rightDep = maxDepth(root.right);
        return Math.max(leftDep, rightDep) + 1;
    }
} 

力扣测试时间为0ms, 空间为39.5mb, 这种算法简单高效

复杂度分析：

时间复杂度：需要对每个结点进行访问，所以时间复杂度为O(n)

空间复杂度：O(h), h最大为n(当树退化成链表时),所以空间复杂度为O(n), 在最好的情况下，也就是树是平衡的，这样数的高度就是O(logn), 此时空间复杂度就为O(logn)

思路二：BFS迭代

1. 外层循环每次迭代一层

2. 内层循环弹出该层的所有结点，入队下一层的所有结点

// BFS计算深度
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int dept = 0;
        while(!queue.isEmpty()){
            int count = queue.size();   // 当前层次的结点个数
            dept++;
            // 弹出该层的所有结点，入队下一层的所有结点
            for(int i = 0; i < count; i++){
                TreeNode node = queue.poll();
                if(node.left != null)
                    queue.offer(node.left);
                if(node.right != null)
                    queue.offer(node.right);
            }
        }
        return dept;
    }
}

力扣测试时间为：1ms, 空间为37.7MB

复杂度分析：

时间复杂度：对每个结点进行了一次遍历，所以时间复杂度为O(n)

空间复杂度：空间复杂度就是队列的大小，队列存储的是一层的结点，最坏情况下，只有两层，这样空间复杂度就为O(n/2), 也就是O(n)

BFS的另一种写法

用一个Pair<TreeNode, Integer> 来表示一个结点，Integer表示该结点的高度，将这样的结点存入queue中，这样每次获得结点的同时都能获得该结点的高度

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<Pair<TreeNode, Integer>> queue = new LinkedList<>();
        queue.offer(new Pair(root, 1));
        int dept = 0;
        while(!queue.isEmpty()){
            // 弹出一个结点
            Pair<TreeNode, Integer> top = queue.poll();
            root = top.getKey();
            int currentDep = top.getValue();
            dept = Math.max(currentDep, dept);      // 更新最大高度
            // 将左右孩子结点入队，但是高度标记为父节点加一
            if(root != null){
                if(root.left != null)
                    queue.offer(new Pair(root.left, currentDep + 1));
                if(root.right != null)
                    queue.offer(new Pair(root.right, currentDep + 1));
            }
        }
        return dept;
    }
}

力扣测试的时间为：3ms, 空间为 39.3mb, 是三种方法中的最慢的一种

复杂度分析：

空间复杂度和时间复杂度都为O(n)

思路参考：

https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/solution/er-cha-shu-de-zui-da-shen-du-by-leetcode/