Balanced Binary Tree

使用辅助函数height(root)，如果以root为根的树是balanced，则返回该树的高度，否则返回-1。代码如下：

class Solution {
public:
    bool isBalanced(TreeNode *root) {
        return height(root) >= 0;
    }
    
    //if the root is not a balance tree, return -1;
    //otherwise return the height or the tree.
    int height(TreeNode *root)
    {
        if(root == NULL) return 0;
        
        int left = height(root->left);
        int right= height(root->right);
        
        if(left==-1 || right==-1 || abs(left-right)>1) return -1;
        
        return max(left, right)+1;
    }
};

非递归写法。

class Solution {
public:
    bool isBalanced(TreeNode *root) {
        if(root == NULL) return true;
        unordered_map<TreeNode*, int> map;
        stack<pair<TreeNode*,int> > stack;
        
        stack.push(make_pair(root, 0));
        while(!stack.empty())
        {
            TreeNode *cur = stack.top().first;
            int status = stack.top().second;
            
            if(status < 2)
            {
                stack.top().second++;
                if(status == 0 && cur->left)
                {
                    stack.push(make_pair(cur->left, 0));
                }
                if(status == 1 && cur->right)
                {
                    stack.push(make_pair(cur->right, 0));
                }
            }
            else
            {
                int left_height = cur->left? map[cur->left]:0;
                int right_height= cur->right? map[cur->right]:0;
                
                if(abs(left_height-right_height) > 1) return false;
                map[cur] = max(left_height, right_height) + 1;
                
                stack.pop();
            }
        }
        return true;
    }
};