1
2

输入：root = [3,9,20,null,null,15,7]
输出：true

1
2

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

1
2

输入：root = []
输出：true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// @lc code=start
// Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
//   pub val: i32,
//   pub left: Option<Rc<RefCell<TreeNode>>>,
//   pub right: Option<Rc<RefCell<TreeNode>>>,
// }
//
// impl TreeNode {
//   #[inline]
//   pub fn new(val: i32) -> Self {
//     TreeNode {
//       val,
//       left: None,
//       right: None
//     }
//   }
// }
use std::cell::RefCell;
use std::rc::Rc;
impl Solution {
    /// ## 解题思路
    /// - 递归
    pub fn is_balanced(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
        type TreeNodeOpt = Option<Rc<RefCell<TreeNode>>>;
        fn get_height(root: &TreeNodeOpt) -> i32 {
            match root {
                None => 0,
                Some(node) => {
                    get_height(&node.borrow().left).max(get_height(&node.borrow().right)) + 1
                }
            }
        }

        match &root {
            None => true,
            Some(root) => {
                Solution::is_balanced(root.borrow().left.clone())
                    && Solution::is_balanced(root.borrow().right.clone())
                    && (get_height(&root.borrow().left) - get_height(&root.borrow().right)).abs()
                        <= 1
            }
        }
    }
}
// @lc code=end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Solution {
public:
    /*
    ## 解题思路
    * 平衡二叉树的条件：
      1. 左右子树均为平衡二叉树；
      2. 左右子树高度差不能大于1；
    */
    bool isBalanced(TreeNode* root) {
        if (!root) {
            return true;
        }

        return (isBalanced(root->left)
            && isBalanced(root->right)
            && abs(treeHeigh(root->left) - treeHeigh(root->right)) < 2
            );
    }

    //二叉树的高度
    int treeHeigh(TreeNode *root) {
        if (!root) return 0;
        return max(treeHeigh(root->left), treeHeigh(root->right)) + 1;
    }
};