输入一棵二叉树，判断该二叉树是否是平衡二叉树（Java版）/输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。（Java版）

输入一棵二叉树，判断该二叉树是否是平衡二叉树（Java版）

package Day45;

/**
 * @Author Zhongger
 * @Description 输入一棵二叉树，判断该二叉树是否是平衡二叉树
 * @Date 2020.3.18
 */
public class AVLSolutionClass {
    private boolean flag=false;
    public static void main(String[] args) {

    }
    public boolean IsBalanced_Solution(TreeNode root){
        getDepth(root);
        return flag;
    }
    public int getDepth(TreeNode root){
        if (root==null){
            flag=true;
            return 0;
        }
        int leftDepth=getDepth(root.left);
        int rightDepth=getDepth(root.right);
        int depth=(leftDepth>rightDepth?leftDepth:rightDepth)+1;
        if (Math.abs(leftDepth-rightDepth)>1){
            flag=false;
        }else {
            flag=true;
        }
        return depth;
    }

}
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }

}

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

package Day45;

/**
 * @Author Zhongger
 * @Description 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
 * @Date 2020.3.18
 */
public class TreeDepthsSolutionClass {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        TreeNode a = new TreeNode(2);
        TreeNode b = new TreeNode(2);
        TreeNode c = new TreeNode(2);
        TreeNode d = new TreeNode(2);
        root.left=a;
        a.left=b;
        b.right=c;
        root.right=d；
        //TreeNode root=null;
        System.out.println(new TreeDepthsSolutionClass().TreeDepth(root));//4
    }

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

总结

上面两题都涉及到了二叉树求深度的问题，往往这种类型的题目需要使用递归来求解。