int deep(TreeNode root){
    if(root == null) 
        return 0;
    int left = deep(root.left); 
    int right = deep(root.right);
    //子树最大深度加上自己
    return (left > right) ? left + 1 : right + 1; 
}

判断是否两边相差绝对值超过1：

//左子树深度减去右子树相差绝对值大于1
if(left - right > 1 || left - right < -1) 
    return false;

然后因为每个子树都满足这个条件，我们还需要遍历二叉树每个节点当成一棵子树进行判断，而对于每个每个节点判断后，其子节点就是子问题，因此可以用递归。

IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);

具体做法：

step 1：第一个函数递归遍历二叉树所有节点。
step 2：对于每个节点判断，调用第二个函数获取子树深度。
step 3：第二个函数递归获取子树深度，只需要不断往子节点深度遍历，累加左右深度的较大值。
step 4：根据深度判断该节点下的子树是否为平衡二叉树。

图示：

图片说明

Java实现代码：

public class Solution {
    //计算该子树深度函数
    public int deep(TreeNode root){
        //空节点深度为0
        if(root == null) 
            return 0;
        //递归算左右子树的深度
        int left = deep(root.left); 
        int right = deep(root.right);
        //子树最大深度加上自己
        return (left > right) ? left + 1 : right + 1; 
    }
    
    public boolean IsBalanced_Solution(TreeNode root) {
        //空树为平衡二叉树
        if (root == null) 
            return true;
        int left = deep(root.left);
        int right = deep(root.right);
        //左子树深度减去右子树相差绝对值大于1
        if(left - right > 1 || left - right < -1) 
            return false;
        //同时，左右子树还必须是平衡的
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
    }
}

C++实现代码：

class Solution {
public:
    //计算该子树深度函数
    int deep(TreeNode* root){
        //空节点深度为0
        if(root == NULL) 
            return 0;
        //递归算左右子树的深度
        int left = deep(root->left); 
        int right = deep(root->right);
        //子树最大深度加上自己
        return (left > right) ? left + 1 : right + 1; 
    }
    bool IsBalanced_Solution(TreeNode* pRoot) {
        //空树为平衡二叉树
        if(pRoot == NULL) 
            return true;
        int left = deep(pRoot->left);
        int right = deep(pRoot->right);
        //左子树深度减去右子树相差绝对值大于1
        if(left - right > 1 || left - right < -1){ 
            return false;
        }
        //同时，左右子树还必须是平衡的
        return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);
    }
};

Python实现代码

class Solution:
    #计算该子树深度函数
    def deep(self, root: TreeNode):
        if not root:
            return 0
        # 递归算左右子树的深度
        left = self.deep(root.left) 
        right = self.deep(root.right)
        # 子树最大深度加上自己
        return left + 1 if left > right else right + 1
        
    def IsBalanced_Solution(self , pRoot: TreeNode) -> bool:
        # 空树为平衡二叉树
        if not pRoot: 
            return True
        left = self.deep(pRoot.left)
        right = self.deep(pRoot.right)
        # 左子树深度减去右子树相差绝对值大于1
        if left - right > 1 or left - right < -1: 
            return False
        # 同时，左右子树还必须是平衡的
        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)

复杂度分析：

时间复杂度： $O (n^{2})$ ，其中 $n$ 为二叉树的节点数，第一个递归遍历二叉树所有节点，第二个递归查找深度最坏情况下（二叉树退化为链表）需要遍历二叉树所有节点
空间复杂度： $O (n)$ ，递归栈最大深度为 $n$

方法二：自底向上（扩展思路）

思路：

上述一个函数算深度，一个函数遍历所有节点的方法，用了两个递归，做了很多不必要的运算，这就是自顶向下的弊端。那我们可以考虑自底向上，因为其实我们判断某个节点是否符合平衡二叉树特性的时候，需要的不是左右子树的完整深度，而是深度差，只要深度差绝对值不超过1，就可以满足。因此在底部计算深度的同时，判断该子树是否为平衡二叉树，将是或否与深度差一起往上传就行。