Print all palindromic paths of binary tree

/*
    C Program 
    Print all palindromic paths of binary tree
*/
#include <stdio.h>

#include <stdlib.h>

// Tree Node
struct TreeNode
{
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
};
// Binary Tree
struct BinaryTree
{
    struct TreeNode *root;
};
// Create new tree
struct BinaryTree *new_tree()
{
    // Create dynamic node
    struct BinaryTree *tree = (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
    if (tree != NULL)
    {
        tree->root = NULL;
    }
    else
    {
        printf("Memory Overflow to Create tree Tree\n");
    }
    //return new tree
    return tree;
}
// returns a new node of tree
struct TreeNode *new_node(int data)
{
    // Create dynamic node
    struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    if (node != NULL)
    {
        //Set data and pointer values
        node->data = data;
        node->left = NULL;
        node->right = NULL;
    }
    else
    {
        //This is indicates, segmentation fault or memory overflow problem
        printf("Memory Overflow\n");
    }
    //return new node
    return node;
}
// This are check whether given path contains palindrome or not
int isPalindrom(int auxiliary[], int length)
{
    int a = 0;
    int b = length;
    while (a < b)
    {
        if (auxiliary[a] != auxiliary[b])
        {
            return 0;
        }
        // Update element location
        a++;
        b--;
    }
    // When palindrome exists
    return 1;
}
// This function are printing given path which is contain palindromes
void printPath(int auxiliary[], int size)
{
    for (int i = 0; i <= size; ++i)
    {
        // Display node value
        printf("  %d", auxiliary[i]);
    }
    printf("\n");
}
// Collect all paths from root to leaf nodes
// And path contains palindrome then this are request to print resultant data
void findPath(struct TreeNode *node, int auxiliary[], int location)
{
    if (node != NULL)
    {
        auxiliary[location] = node->data;
        if (node->left == NULL && node->right == NULL)
        {
            if (isPalindrom(auxiliary, location))
            {
                // When palindrome exist
                printPath(auxiliary, location);
            }
            return;
        }
        // Collecting path through by recursion
        findPath(node->left, auxiliary, location + 1);
        findPath(node->right, auxiliary, location + 1);
    }
}
//Find height of given binary tree
int height(struct TreeNode *root)
{
    if (root != NULL)
    {
        int a = height(root->left);
        int b = height(root->right);
        //returning a height of largest subtree
        if (a > b)
        {
            return a + 1;
        }
        else
        {
            return b + 1;
        }
    }
    return 0;
}
void palindromicPath(struct TreeNode *root)
{
    int size = height(root);
    // auxiliary space which is used to collect path
    int auxiliary[size];
    findPath(root, auxiliary, 0);
}
int main()
{
    struct BinaryTree *tree = new_tree();
    /*
            4
           / \
          5   7
         / \   \
        5   3   7
       /   / \   \
      4   4   5   4
             / \
            1   4
    -----------------------
        Binary Tree
    */
    tree->root = new_node(4);
    tree->root->left = new_node(5);
    tree->root->right = new_node(7);
    tree->root->left->left = new_node(5);
    tree->root->left->left->left = new_node(4);
    tree->root->left->right = new_node(3);
    tree->root->left->right->left = new_node(4);
    tree->root->left->right->right = new_node(5);
    tree->root->left->right->right->left = new_node(5);
    tree->root->left->right->right->right = new_node(4);
    tree->root->right->right = new_node(7);
    tree->root->right->right->right = new_node(4);
    palindromicPath(tree->root);
    return 0;
}

Output

  4  5  5  4
  4  5  3  5  4
  4  7  7  4