给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例1：

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

示例2：

输入：root = []
输出：true

这道题是 【力扣104. 二叉树的最大深度】 的延伸版本。

自顶向下

构造一个获取当前节点最大深度的方法 depth(root) ，通过比较此子树的左右子树的最大高度差 abs(depth(root.left) - depth(root.right)) 来判断此子树是否是二叉平衡树。树的所有子树都平衡时，此树才平衡。

1. 函数 isBalanced(root)：判断树 root 是否平衡

   • 特例处理： 若根结点 root 为空，则直接返回 true

   • 返回值： 所有子树都需要满足平衡树性质，因此以下三者使用与逻辑 & 连接

     • abs(self.depth(root.left) - self.depth(root.right)) <= 1：判断 当前子树 是否是平衡树（也可以表示为 差值绝对值 < 2）

     • self.isBalanced(root.left)：先序遍历递归，判断 当前子树的左子树 是否是平衡树

     • self.isBalanced(root.right)：先序遍历递归，判断 当前子树的右子树 是否是平衡树

2. 函数 depth(root)：计算树 root 的最大高度

   • 终止条件：当 root 为空，即越过叶子节点，则返回高度 0

   • 返回值：返回左 / 右子树的最大高度 加 1

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        if not root:
            return True
        return abs(self.height(root.right) - self.height(root.left)) < 2 and self.isBalanced(root.left) and self.isBalanced(root.right)

    # 求高度
    def height(self, node):
        if not node:
            return 0
        return 1 + max(self.height(node.left), self.height(node.right))

时间复杂度 O(nlog_2 n)，其中 n 是二叉树中的节点个数。。最坏情况下，isBalanced(root) 遍历树所有节点，占用 O(n)；判断每个节点的最大高度 depth(root) 需要遍历各子树的所有节点，子树的节点数的复杂度为 O(log_2 n)

空间复杂度：O(n)空间复杂度主要取决于递归调用的层数，递归调用的层数不会超过 n。

自底向上

对二叉树做后序遍历，从底至顶返回子树最大高度，只要判定某子树不是平衡树则 “剪枝” ，直接向上返回不是这里要求的平衡树。

1. 函数 recur(root):

   • 递归返回值：

     • 当结店root 左 / 右子树的高度差 < 2 ：则返回以结点 root 为根结点的子树的最大高度，即结点 root 的左右子树中最大高度加 1 （ max(left, right) + 1 ）

     • 当结点root 左 / 右子树的高度差 > 1（也就是 else 的情况） ：则返回 −1 ，代表 此子树不是平衡树

   • 递归终止条件：

     • 当越过叶子节点时，返回高度 0

     • 当 左（右）子树高度 == -1 时，代表此子树的 左（右）子树 不是平衡树，因此直接返回 -1 ；

2. 函数isBalanced(root)：

   • 返回值：若 recur(root) != 1 ，则说明此树平衡，返回 true
   • 否则返回 false

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        return self.recur(root) != -1 # 结果不是 -1 说明是这里的平衡树，是 -1 则不是平衡树

    def recur(self, root):
        if not root:
            return 0
        # 返回左(右)子树的深度，如果深度为 -1（不平衡），则全树不平衡
        left = self.recur(root.left)
        if left == -1: # 左子树不是平衡树
            return -1
        right = self.recur(root.right)
        if right == -1: # 右子树不是平衡树
            return -1
        return 1 + max(left, right) if abs(left - right) < 2 else -1

时间复杂度：O(n)，其中 n 是二叉树中的节点个数。使用自底向上的递归，每个节点的计算高度和判断是否平衡都只需要处理一次，最坏情况下需要遍历二叉树中的所有节点，因此时间复杂度是 O(n)。

空间复杂度：O(n)。空间复杂度主要取决于递归调用的层数，递归调用的层数不会超过 n。