二叉树的深度&平衡二叉树&二叉树的直径

二叉树的深度

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

给定二叉树 `[3,9,20,null,null,15,7]`，
    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 

递归：

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

层次遍历:

public int maxDepth(TreeNode root) {
    if(root==null){
        return 0;
    }
    Queue queue=new LinkedList<>();
    queue.offer(root);
    int dept=0;
    while(!queue.isEmpty()){
        //当前队列的大小即为这一层结点的个数
        int count=queue.size();
        //将这一层所有结点的孩子加入队列
        for (int i = 0; i 

二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

层次
当遇到左右子树都为空的时候返回

public int minDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    Queue queue = new LinkedList<>();
    queue.offer(root);
    int depth = 0;
    while (!queue.isEmpty()) {
        int count = queue.size();
        depth++;
        for (int i = 0; i < count; i++) {
            TreeNode node = queue.poll();
            if (node.left == null && node.right == null) {
                return depth;
            }
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }
    return 0;
}

递归

public int minDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    if (root.left == null && root.right == null) {
        return 1;
    }
    int min = Integer.MAX_VALUE;
    if (root.left != null) {
        min = Math.min(min, minDepth(root.left));
    }
    if (root.right != null) {
        min = Math.min(min, minDepth(root.right));
    }
    return min + 1;
}

N 叉树的最大深度

给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：3

迭代

public int maxDepth(Node root) {
    if (root == null) {
        return 0;
    }
    Queue queue = new LinkedList<>();
    queue.offer(root);
    int depth = 0;
    while (!queue.isEmpty()) {
        int count = queue.size();
        for (int i = 0; i < count; i++) {
            root = queue.poll();
            for (Node node : root.children) {
                queue.add(node);
            }
        }
        depth++;
    }
    return depth;
}

递归

public int maxDepth(Node root) {
    if (root == null) {
        return 0;
    }
    int depth = 0;
    for (Node node : root.children) {
        depth = Math.max(depth, maxDepth(node));
    }
    return depth + 1;
}

平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]
  3
   / \
  9  20
    /  \
   15   7
返回 true

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]
      1
      / \
     2   2
    / \
   3   3
  / \
 4   4
返回 `false` 

限制：

• 1 <= 树的结点个数 <= 10000

方法一：自顶向下

• 判断当前子树是否平衡
• 判断左子树是否平衡
• 判断右子树是否平衡
  明显会存在重复计算

public boolean isBalanced(TreeNode root) {
    if (root == null) {
        return true;
    }
    return Math.abs(maxDepth(root.left) - maxDepth(root.right)) <= 1
        && isBalanced(root.left) && isBalanced(root.right);
}

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

时间复杂度：O(nlogn)
isBalanced会遍历所有结点O(n)，计算结点的深度O(logn)
空间复杂度：O(n)
如果树完全倾斜，递归栈可能包含所有节点

方法二：自底向上
先判断子树是否平衡（如果不平衡直接返回），再判断当前是否平衡

public boolean isBalanced(TreeNode root) {
    return depth(root) != -1;
}

public int depth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftDepth = depth(root.left);
    if (leftDepth == -1) {//不平衡，剪枝
        return -1;
    }
    int rightDepth = depth(root.right);
    if (rightDepth == -1) {
        return -1;
    }
    return Math.abs(leftDepth - rightDepth) <= 1 ?
        Math.max(leftDepth, rightDepth) + 1 : -1;
}

时间复杂度O(n)
空间复杂度O(n)

二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

示例 :
给定二叉树

          1
         / \
        2   3
       / \     
      4   5    

返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]

相当于计算两个结点间的路径长度，最长的路径必定来自于叶子结点
两个叶子结点的路径等于两个结点的深度之和
相当于找到哪两个叶子结点的深度之后最大

private int maxDiameter;

public int diameterOfBinaryTree(TreeNode root) {
    depth(root);
    return maxDiameter;
}

public int depth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftDepth = depth(root.left);
    int rightDepth = depth(root.right);
    maxDiameter = Math.max(maxDiameter, leftDepth + rightDepth);
    return Math.max(leftDepth, rightDepth) + 1;
}