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.

#include <cstdlib>
#include <iostream>

struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x):val(x),left(nullptr),right(nullptr){}
};

class Solution {
public:
    bool isBalanced(TreeNode* root) {
        int depth=0;
        return helper(root,depth);
    }
    bool helper (TreeNode* root,int& depth) {
        if (root == nullptr){
            depth = 0;
            return true;
        }
        int ld,rd;
        if(helper(root->left,ld) && helper(root->right,rd)){
            if(abs(ld-rd)>1){
                return false;
            }
            depth = ld>rd? ld+1 : rd+1;
        }
    }
};

/**
Function:compute the depth of a binary tree.
*/

int treeDepth(TreeNode* root)
{
    if(!root) return 0;
    int ld = treeDepth(root->left);
    int rd = treeDepth(root->right);
    return ld > rd ? ld + 1 : rd + 1;
}

int main()
{
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(5);
    root->left->right = new TreeNode(3);
    root->left->right->right = new TreeNode(4);

    Solution s;
    s.isBalanced(root);
    std::cout << treeDepth(root) << std::endl;

    return 0;
}