K dimensional tree insertion

// C program for
// K dimensional tree insertion
#include <stdio.h>

#include <stdlib.h>

// Define tree node
struct TreeNode
{
    int *keys;
    struct TreeNode *left;
    struct TreeNode *right;
};
struct KTree
{
    int k;
    struct TreeNode *root;
};
// Returns the new K Dimensional Tree
struct KTree *createTree(int k)
{
    struct KTree *tree = (struct KTree *) malloc(sizeof(struct KTree));
    if (tree != NULL)
    {
        tree->k = k;
        tree->root = NULL;
    }
    else
    {
        printf("\n Memory Overflow when create new Tree");
    }
}
// Creating and returning new node of tree
struct TreeNode *createNode(int data[], int k)
{
    struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
    if (node != NULL)
    {
        // Create memory of node key
        node->keys = (int *) malloc((sizeof(int)) *(2));
        node->left = NULL;
        node->right = NULL;
        for (int i = 0; i < k; i++)
        {
            node->keys[i] = data[i];
        }
    }
    else
    {
        printf("\n Memory Overflow when create new node Tree");
    }
    return node;
}
// Handles the request to add new node in Tree
void insert(struct KTree *tree, int data[])
{
    if (tree->root == NULL)
    {
        // When add first node of tree
        tree->root = createNode(data, tree->k);
    }
    else
    {
        struct TreeNode *auxiliary = tree->root;
        int depth = 0;
        int axis = 0;
        // Add new node in tree
        while (auxiliary != NULL)
        {
            axis = depth % tree->k;
            if (auxiliary->keys[axis] > data[axis])
            {
                if (auxiliary->left == NULL)
                {
                    // Add new node
                    auxiliary->left = createNode(data, tree->k);
                    // break the loop
                    auxiliary = NULL;
                }
                else
                {
                    // visit left subtree
                    auxiliary = auxiliary->left;
                }
            }
            else
            {
                if (auxiliary->right == NULL)
                {
                    // Add new node
                    auxiliary->right = createNode(data, tree->k);
                    // break the loop
                    auxiliary = NULL;
                }
                else
                {
                    // visit right subtree
                    auxiliary = auxiliary->right;
                }
            }
            depth++;
        }
    }
}
//  Print the all key of a given node
void printData(int data[], int k)
{
    printf(" (");
    for (int i = 0; i < k; ++i)
    {
        if (i > 0)
        {
            printf(" , %d", data[i]);
        }
        else
        {
            printf(" %d", data[i]);
        }
    }
    printf(")\n");
}
// Display tree node
void printTree(struct TreeNode *node, int k)
{
    if (node != NULL)
    {
        printTree(node->left, k);
        printData(node->keys, k);
        printTree(node->right, k);
    }
}
// Compare node and given point
int isEquals(int node[], int point[], int k)
{
    for (int i = 0; i < k; ++i)
    {
        if (node[i] != point[i])
        {
            return 0;
        }
    }
    //  When both are same
    return 1;
}
// Check if given point exists in tree or not
void search(struct KTree *tree, int point[])
{
    if (tree->root != NULL)
    {
        struct TreeNode *auxiliary = tree->root;
        int depth = 0;
        int axis = 0;
        int result = 0;
        // Find node point
        while (auxiliary != NULL && result == 0)
        {
            axis = depth % tree->k;
            if (isEquals(auxiliary->keys, point, tree->k) == 1)
            {
                // When get resultant node
                result = 1;
                auxiliary = NULL;
            }
            else if (auxiliary->keys[axis] > point[axis])
            {
                // visit left subtree
                auxiliary = auxiliary->left;
            }
            else
            {
                // visit right subtree
                auxiliary = auxiliary->right;
            }
            depth++;
        }
        printf("\n Given point : ");
        printData(point, tree->k);
        if (result == 1)
        {
            printf(" Found \n");
        }
        else
        {
            printf(" Not Found \n");
        }
    }
    else
    {
        printf("\n Empty Tree");
    }
}
int main(int argc, char const *argv[])
{
    // Number of Dimensions
    int k = 2;
    struct KTree *tree = createTree(k);
    // 2d points
    int data[][2] = {
        {
            8 , 2
        },
        {
            7 , 4
        },
        {
            3 , 5
        },
        {
            11, 2
        },
        {
            5 , 8
        },
        {
            9 , 4
        },
        {
            2 , 3
        }
    };

    // Get the number of elements
    int n = sizeof(data) / sizeof(data[0]);
    // Insert all given nodes
    for (int i = 0; i < n; ++i)
    {
        insert(tree, data[i]);
    }
    printf("\n Tree Nodes\n");
    /*
        (8,2)
        /    \
      (7,4)  (11,2)     
      /   \     \
    (2,3) (3,5)  (9,4)
            \
             (5,8)          
    -----------------
    Developed tree
    */
    // Print  tree elements in inorder  form
    printTree(tree->root, tree->k);

    // Search nodes
    int point1[] = {
        8 , 1
    };
    int point2[] = {
        5 , 8
    };
    int point3[] = {
        5 , 4
    };
    // Test case for find nodes
    search(tree, point1);
    search(tree, point2);
    search(tree, point3);
    return 0;
}

Output

 Tree Nodes
 ( 2 , 3)
 ( 7 , 4)
 ( 3 , 5)
 ( 5 , 8)
 ( 8 , 2)
 ( 11 , 2)
 ( 9 , 4)

 Given point :  ( 8 , 1)
 Not Found

 Given point :  ( 5 , 8)
 Found

 Given point :  ( 5 , 4)
 Not Found