isBalanced cpp

// function to print if the given binary tree is balanced or not
#include <iostream>

using namespace std;

// node class
class node{
public:
    int data;
    int hd;
    node* left;
    node* right;
};

// function that returns a pointer to new node
node* createNode(int element){
    node* temp = (node*) malloc(sizeof(node));
    temp->data = element;
    temp->hd = -1;
    temp->left = NULL;
    temp->right = NULL;
    return temp;
}

// function to find the height of a binary tree
int height(node* root){
    if (root == NULL){
        return 0;
    }
    return (1 + max(height(root->left), height(root->right)));
}

// function to check if the tree is a height balanced tree or not
bool isBalanced(node* root){
    if(root == NULL){
        return true;
    }
    // get the heights of the left and the right subtrees
    int left_height = height(root->left);
    int right_height = height(root->right);
    // if the difference between heights of the left and right subtrees is less than 2
    // and left and right subtrees are also balanced then return true
    return abs(left_height - right_height) <= 1 && isBalanced(root->left) && isBalanced(root->right);

}

int main() {

    node* head = createNode(1);
    head->left = createNode(2);
    head->right = createNode(3);
    head->left->left = createNode(4);
    head->left->right = createNode(5);
    head->right->right = createNode(6);
    head->left->left->right = createNode(7);
    head->right->right->left = createNode(8);
    head->left->left->right->left = createNode(9);
    head->left->left->right->left->left = createNode(10);
    head->right->right->left->right = createNode(11);
    cout<<"The binary tree #1 is Balanced : "<<isBalanced(head)<<endl;

    node* head2 = createNode(5);
    head2->left = createNode(2);
    head2->right = createNode(12);
    head2->left->left = createNode(-4);
    head2->left->right = createNode(3);
    head2->right->left = createNode(9);
    head2->right->right = createNode(21);
    head2->right->right->left = createNode(19);
    head2->right->right->right = createNode(25);
    cout<<"The binary tree #2 is Balanced : "<<isBalanced(head2)<<endl;

    node* m1 = createNode(8);
    m1->left = createNode(3);
    m1->right = createNode(10);
    m1->left->left = createNode(1);
    m1->left->right = createNode(6);
    m1->left->right->left = createNode(4);
    m1->left->right->right = createNode(7);
    m1->right->right = createNode(14);
    m1->right->right->left = createNode(13);
    cout<<"The binary tree #3 is Balanced : "<<isBalanced(m1);

}



/*


The binary tree #1 is Balanced : 0
The binary tree #2 is Balanced : 1
The binary tree #3 is Balanced : 0
Process finished with exit code 0

*/