java算法第十六天 | ● 104.二叉树的最大深度 559.n叉树的最大深度 ● 111.二叉树的最小深度 ● 222.完全二叉树的节点个数

104.二叉树的最大深度

题目链接/文章讲解/视频讲解：
本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
  而根节点的高度就是二叉树的最大深度，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度。

这里选择递归方法实现

/**
 * 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 maxDepth(TreeNode root) {
        return getMaxdepth(root);

    }

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

    }
}

559.n叉树的最大深度

解题思路通同二叉树最大深度

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public int maxDepth(Node root) {
        return getMaxDepth(root);
        
    }

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

111.二叉树的最小深度

题目链接/文章讲解/视频讲解：

先看视频讲解，和最大深度 看似差不多，其实 差距还挺大，有坑。

这就重新审题了，题目中说的是：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点。

什么是叶子节点，左右孩子都为空的节点才是叶子节点！

遍历的顺序为后序（左右中），可以看出：求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑。

/**
 * 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 minDepth(TreeNode root) {
        return getMinDepth(root);

    }

    public int getMinDepth(TreeNode node){
        if(node==null) return 0;
        int left=getMinDepth(node.left);
        int right=getMinDepth(node.right);
        if(left==0 && right!=0) return right+1;
        if(left!=0 && right==0) return left+1;
        return Math.min(left,right)+1;
    }
}

222.完全二叉树的节点个数

题目链接/文章讲解/视频讲解：
完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

可以看出如果整个树不是满二叉树，就递归其左右孩子，直到遇到满二叉树为止，用公式计算这个子树（满二叉树）的节点数量。

这里关键在于如何去判断一个左子树或者右子树是不是满二叉树呢？

在完全二叉树中，如果递归向左遍历的深度等于递归向右遍历的深度，那说明就是满二叉树。如图：

/**
 * 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 countNodes(TreeNode root) {
        return count(root);
    }

    public int count(TreeNode node){
        if(node==null) return 0 ;
        int left=0,right=0;
        TreeNode cur=node;
        while(cur!=null){
            cur=cur.left;
            left++;
        }
        cur=node;
        while(cur!=null){
            cur=cur.right;
            right++;
        }
        if(left==right) return (2<<(left-1))-1;//注意(2<<1) 相当于2^2，返回满足满二叉树的子树节点数量
        int numsLeft=count(node.left);
        int numsRight=count(node.right);
        return numsLeft+numsRight+1;
    }
}