leetcode110

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private int height(TreeNode node)
        {
            if (node == null)
            {
                return 0;
            }
            int lH = height(node.left);
            if (lH == -1)
            {
                return -1;
            }
            int rH = height(node.right);
            if (rH == -1)
            {
                return -1;
            }
            if (lH - rH < -1 || lH - rH > 1)
            {
                return -1;
            }
            return Math.Max(lH, rH) + 1;
        }

        public bool IsBalanced(TreeNode root)
        {
            if (root == null)
            {
                return true;
            }
            return height(root) != -1;

        }
}

https://leetcode.com/problems/balanced-binary-tree/#/description

 

补充一个python的实现：

class Solution:
    def __init__(self):
        self.result = True
        
    def maxDepth(self,root):
        if root == None:
            return 0
        l = self.maxDepth(root.left)
        r = self.maxDepth(root.right)
        d = max(l,r) + 1
        if abs(l - r) > 1:
            self.result = False
        return d
    
    def isBalanced(self, root: TreeNode) -> bool:
        self.maxDepth(root)
        return self.result

 

Java版本：

class Solution {
    public boolean isBalanced(TreeNode root) {
        return height(root) >= 0;
    }

    public int height(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        if (leftHeight == -1 || rightHeight == -1 || Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        } else {
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }
}