33-二叉树练习-LeetCode110平衡二叉树

题目

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

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例 1：

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

示例 2：

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

示例 3：

输入：root = []
输出：true

提示：

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

---

思路1：递归，方法调用

---

代码1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        //空树
        if(root == null) {
            return true;
        }
        //求当前的左右子树高度
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        int heightAbs = Math.abs(leftHeight - rightHeight); //Math.abs()求绝对值
        if(heightAbs > 1) {
            return false;
        }
        //递归求左树和右树是否同时是平衡树
        return isBalanced(root.left) && isBalanced(root.right);
    }

    /**
     * 求树的高度
     * @param root
     * @return
     */
    public int height(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return 1 + Math.max(height(root.left), height(root.right));
    }
}

---

思路2：优化

在递归求每个节点高度时，多个节点可能会重复递归计算。

可以使用Map存储每个节点及其高度：当一个节点在Map中存在，直接从Map中取高度即可。

---

代码2

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //使用map存储每个出现节点的高度
    //要放在isBalanced方法外，会减小内存；若放在isBalanced方法里面，会失效。
    //因为若放在递归函数中，每调用一次isBalanced方法都会新建一个map，最终会return一个空的。
    Map<TreeNode, Integer> map = new HashMap<>();
    
    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        
        int leftHeight = 0, rightHeight = 0;

        //左树
        if (map.containsKey(root.left)) {
            //root.left节点的高度已经算过，存在map中了
            leftHeight = map.get(root.left);
        } else {
            //通过递归函数计算该节点高度并放入map中
            leftHeight = height(root.left);
            map.put(root.left, leftHeight);
        }

        //右树
        if (map.containsKey(root.right)) {
            //root.right节点的高度已经算过，存在map中了
            rightHeight = map.get(root.right);
        } else {
            //通过递归函数计算该节点高度并放入map中
            rightHeight = height(root.right);
            map.put(root.right, rightHeight);
        }

        int heightAbs = Math.abs(leftHeight - rightHeight);
        if (heightAbs > 1) {
            return false;
        }
        
        //递归去看左树和右树是否同时是平衡树
        return isBalanced(root.left) && isBalanced(root.right);
    }
    
    /**
     * 求树的高度
     * @param root
     * @return
     */
    public int height(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return 1 + Math.max(height(root.left), height(root.right));
    }
}