判断是否为平衡二叉树（查找的属性不做要求）

平衡二叉树：首先它是一个二叉查找树（这个题目没做要求），每个节点的子树长度差不超过1。
我的想法：遍历每一个节点，然后计算这个节点所有的子树的长度，然后判断长度差是否超过1。

大佬的想法：平衡二叉树的子树也是平衡二叉树，那么只要判断节点的左右子树是不是平衡二叉树，然后再判断它们的长度差是否超过1即可。（思路清晰）

复杂冗长还不是最优的代码
import java.util.*;
public class Solution {
boolean check(ArrayList<integer> lenList){
int tempMax = lenList.get(0);
int tempMin = lenList.get(0);
for(Integer num: lenList){
if(num>tempMax){
tempMax = num;
}
if(num<tempMin){
tempMin = num;
}
}
return Math.abs(tempMax-tempMin)<=1;
}</integer>

void dfs(TreeNode root, int len, ArrayList<Integer> lenList){
    // 节点的左右孩子都不存在则到底了
    if(root.left==null&&root.right==null){
        lenList.add(len);
        return;
    }
    // 左孩子还在就遍历做孩子
    if(root.left!=null){
        dfs(root.left, len+1, lenList);
    }
    // 右孩子还在就遍历右孩子
    if(root.right!=null){
        dfs(root.right, len+1, lenList);
    }
}


public boolean IsBalanced_Solution(TreeNode root) {
    // 以每个节点作为根节点，然后看他下面的子树长度只差为1
    // 先要遍历每一个节点，
    if(root!=null){
        // 以当前节点
        // 如果没有子节点，那么长度就是1，满足
        if(root.left==null&&root.right==null){
            return true;
        }
        // 用来统计每个节点每条路径的长度的
        ArrayList<Integer> lenList = new ArrayList<>();
        // 如果该节点存在着一边是空的，那肯定就有一条深度为1的路径。
        if(root.left==null||root.right==null){
            lenList.add(1);
        }
        int len = 0;
        dfs(root, len+1, lenList);
        // 判断
        if(!check(lenList)){
            return false; 
        }
        // 自己的子节点
        boolean b1 = IsBalanced_Solution(root.left);
        boolean b2 = IsBalanced_Solution(root.right);
        return b1&&b2;
    }else {
        return true;
    }
}

}

大佬的解法

public class Solution {
    int depth(TreeNode root){
        // 为空节点不存在长度为0
        if(root==null){
            return 0;
        }
        // 获取最大长度，如果为-1，表示不是平衡树
        int left = depth(root.left);
        if(left==-1){
            return -1;
        }
        int right = depth(root.right);
        if(right==-1){
            return -1;
        }
        // 判断左右子树相差是否大于1
        if(Math.abs(left - right)>1){
            return -1;
        }
        // 选最大值+1
        return Math.max(left, right)+1;
    }
    public boolean IsBalanced_Solution(TreeNode root) {
        return depth(root)!=-1;
    }
}