Check if Binary Tree is Balanced

#include <stdio.h>
#include <stdlib.h>

// Definition for a binary tree node.
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// Function to create a new node.
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// Function to find the height of a tree.
// Returns -1 if the tree is unbalanced.
int height(struct Node* root) {
    // An empty tree has a height of 0.
    if (root == NULL)
        return 0;

    // Get the height of the left and right subtrees.
    int leftHeight = height(root->left);
    int rightHeight = height(root->right);

    // If left or right subtree is unbalanced, return -1.
    if (leftHeight == -1 || rightHeight == -1)
        return -1;

    // If the difference in height between left and right subtrees is more than 1, return -1.
    if (abs(leftHeight - rightHeight) > 1)
        return -1;

    // Otherwise, return the height of the tree.
    return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}

// Function to check if the tree is balanced.
int isBalanced(struct Node* root) {
    return height(root) != -1;
}

// Main function to test the above functions.
int main() {
    struct Node* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->left->left->left = createNode(8);

    if (isBalanced(root))
        printf("The binary tree is balanced.\n");
    else
        printf("The binary tree is not balanced.\n");

    return 0;
}