110. Balanced Binary Tree

题目：

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Hide Tags

 Tree Depth-first Search 

链接： http://leetcode.com/problems/balanced-binary-tree/

一刷，recursive解法，时间复杂度：O(N²)

class Solution(object):
    def calculate_depth(self, root):
        if not root:
            return 0
        return max(self.calculate_depth(root.left), self.calculate_depth(root.right)) + 1

    def isBalanced(self, root):
        if not root:
            return True
        return self.isBalanced(root.left) and self.isBalanced(root.right) and 
        abs(self.calculate_depth(root.left) - self.calculate_depth(root.right)) <= 1

上面的解法中，求左右子树是否balance和求他们的深度是完全重复的。所以每当向上计算到一个节点时，还需要向下找depth，我们可以把两个方面合并成一个，最终只向一个方向（向上）走

class Solution(object):
    def isBalanced(self, root):
        return self.calculate_depth(root) != -1

    @staticmethod
    def calculate_depth(root):
        if not root:
            return 0
        left_depth = Solution.calculate_depth(root.left)
        if left_depth == -1:
            return -1
        right_depth = Solution.calculate_depth(root.right)
        if right_depth == -1:
            return -1
        if abs(left_depth - right_depth) <= 1:
            return max(left_depth, right_depth) + 1
        else:
            return -1

2/17/2017, Java, 薅羊毛

这道题一开始完全算错了，以下例子通不过：1,2,2,3,3,3,3,4,4,4,4,4,4,null,null,5,5

此例按照本题要求应该是true，但是开始理解成从root下去的差不能超过1。做起来又麻烦又错。

public class Solution {
    public boolean isBalanced(TreeNode root) {
        if (subtreeDepth(root) == -1) return false;
        return true;
    }
    int subtreeDepth(TreeNode root) {
        if (root == null) return 0;
        int depthL = subtreeDepth(root.left);
        if (depthL == -1) return -1;
        int depthR = subtreeDepth(root.right);
        if (depthR == - 1) return -1;
        
        if (depthL - depthR > 1 || depthR - depthL > 1) return -1;
        return Math.max(depthL, depthR) + 1;
        
    }
}

5/8/2017

算法班

时间复杂度不好O(n^2)top down，应该参考2/7/2017的解法O(n) bottom up

public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: True if this Binary tree is Balanced, or false.
     */
    public boolean isBalanced(TreeNode root) {
        if (root == null) return true;
        if (isBalanced(root.left) && isBalanced(root.right) && Math.abs(subtreeHeight(root.left) - subtreeHeight(root.right)) <= 1) return true;
        return false;
    }
    private int subtreeHeight(TreeNode root) {
        if (root == null) return 0;
        return Math.max(subtreeHeight(root.left), subtreeHeight(root.right)) + 1;
    }
}

别人的

https://discuss.leetcode.com/topic/7798/the-bottom-up-o-n-solution-would-be-better

关于blanced tree的一些讨论，有AVL和红黑树

https://discuss.leetcode.com/topic/276/two-different-definitions-of-balanced-binary-tree-result-in-two-different-judgments

更多讨论

https://discuss.leetcode.com/category/118/balanced-binary-tree