# 8.Balanced Binary Tree

A binary tree in which the **left and right subtrees** of **every node** **differ in height** by not **more than 1**.

```
Example 1:
Given the following tree [3,9,20,null,null,15,7]:

    3
   / \
  9  20
    /  \
   15   7
Return true


Example 2:
Given the following tree [1,2,2,3,3,null,null,4,4]:

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4
Return false
```

### Solution :

```cpp
class Solution
{

public:
    
    int findHeight(TreeNode *root){
        
        if(root == NULL){
            return 0;
        }
        
        int lh = findHeight(root->left);
        int rh = findHeight(root->right);
        
        return max(lh,rh) + 1;
    }
    
    bool isBalanced(TreeNode *root)
    {

        if (root == NULL)
        {
            return true;
        }

        int lh = findHeight(root->left);
        int rh = findHeight(root->right);

        int x = lh - rh;

        if (abs(x) <= 1 && (isBalanced(root->left)) && (isBalanced(root->right)))
        {
            return true;
        }

    
        return false;
    }
};
```

**Time Complexity: O(n^2)**

## Solution: (Finding height  and checking balanced)

```cpp
class Solution
{
public:
    bool res = true;
    int findHeight(TreeNode *root)
    {

        if (root == NULL)
        {
            return 0;
        }

        int lh = findHeight(root->left);
        int rh = findHeight(root->right);

        if (abs(lh - rh) > 1)
        {
            res = false;
        }

        return max(lh, rh) + 1;
    }

    bool isBalanced(TreeNode *root)
    {

        if (root == NULL)
        {
            return true;
        }

        findHeight(root);

        return res;
    }
};
```

**Time Complexity: O(n)**