[Leetcode 9] 110 Balanced Binary Tree

Problem:

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 everynode never differ by more than 1.

 

Analysis:

This problem is different from the 4.1 problem in Cracking the Code Interview. Their definitions of "Balanced" are different. In the CCI  problem, the definition is “a tree is balanced such that no two leaf nodes differ in distance from the root by more than one“. But here the definition is "the depth of the two subtrees of everynode never differ by more than 1".

For a example, the following binary tree is balanced under the second definition but not balanced under the first definition:

                  1

           2             2

       3     3       3      

    4   4  4  4 

 

Due to the intrinsically recursion of a tree, we can solve the problem in a resursive way. First if the root is null, then it's balanced; else if its two subtree's height differ more than one, it's not balanced; else return if its left and right subtree is balanced

 

Code:

 

Here is a more efficient version with early exit

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isBalanced(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        return height(root) != -1;
    }
    
    
    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;
        
        int height_dif = diff (lh, rh);
        if (height_dif > 1)
            return -1;
        else
            return 1 + max(lh, rh);
    }
    
    
    private int diff(int a, int b) {
        return (a>b) ? (a-b) : (b-a);
    }
    
    private int max(int a, int b) {
        return (a>b) ? a : b;
    }
    
}

 

Attention:

The check balanced function and the height function are some kind of redundant, try to find a way that combine them together thus leaving only one parse of the given binary tree.