题目

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

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

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

示例 1： image.png 输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2： image.png 输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

提示：

树中的节点数在范围 [0, 5000] 内
-10^4 <= Node.val <= 10^4

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/balanced-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

判断以root为根节点的树是不是平衡树，需要求左右子树的高度，如果相差不大于1就是平衡树。求子树高度的同时可以判断左右子树是不是平衡树。因此，是一种后序遍历的方式，先判断左右子树是不是平衡树，再判断根节点的树是不是。

实现上，利用一个辅助函数dfs(root)，用来求root子树的高度，另外使用一个类内变量ans，如果递归过程中发现有左右子树高度相差超过1就将ans置为false。如代码一。

更加优雅的方式是不使用ans变量，将dfs的返回值多加一个作用，不止返回高度，如果左右子树子树不平衡，就返回-1，如果平衡就返回子树高度，这样直接return dfs(root)>=0就好了，很赞。如代码二。

代码

代码一 多使用一个ans变量

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode() {}
  8.  *     TreeNode(int val) { this.val = val; }
  9.  *     TreeNode(int val, TreeNode left, TreeNode right) {
  10.  *         this.val = val;
  11.  *         this.left = left;
  12.  *         this.right = right;
  13.  *     }
  14.  * }
  15.  */
  16. class Solution {
  17.     boolean ans = true;
  19.     public boolean isBalanced(TreeNode root) {
  20.         dfs(root);
  21.         return ans;
  22.     }
  24.     private int dfs(TreeNode root) {
  25.         if (root == null) {
  26.             return 0;
  27.         }
  28.         int left = dfs(root.left);
  29.         int right = dfs(root.right);
  30.         if (left - right > 1 || right - left > 1) {
  31.             ans = false;
  32.             return 0;
  33.         }
  34.         return Math.max(left, right) + 1;
  35.     }
  36. }

代码二 无ans变量(更推荐)

  1. class Solution {
  2.     public boolean isBalanced(TreeNode root) {
  3.         return dfs(root) >= 0;
  4.     }
  6.     // 如果返回正数，表示root子树平衡，同时返回值为root子树高度；如果返回负数-1，表示root子树不平衡
  7.     private int dfs(TreeNode root) {
  8.         if (root == null) {
  9.             return 0;
  10.         }
  11.         int left = dfs(root.left);
  12.         int right = dfs(root.right);
  13.         if (left == -1 || right == -1 || Math.abs(left - right) > 1) {
  14.             return -1;
  15.         }
  16.         return Math.max(left, right) + 1;
  17.     }
  18. }