Find the minimum in K dimensional tree

// C program for
// Find the minimum in K dimensional tree  
#include <stdio.h>

#include <limits.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);
	}
}
// Returns the minimum of given two values
int minValue(int a, int b)
{
	if (a > b)
	{
		return b;
	}
	return a;
}
// Recursively finding the minimum of given dimension
int findMinimum(struct TreeNode *node, int dim, int k, int depth)
{
	if (node == NULL)
	{
		// When get a null Node
		return INT_MAX;
	}
	// Get dimension position
	int position = depth % k;
	if (position == dim)
	{
		// When position are equal to given a dimension
		if (node->left == NULL)
		{
			// Returns the current dimension
			return node->keys[dim];
		}
		return minValue(node->keys[dim], 
                        findMinimum(node->left, dim, k, depth + 1));
	}
	// When position are equal to given a dimension
	// Then resultant node can be exists in left or right subtree
	return minValue(node->keys[dim], 
                    minValue(findMinimum(node->left, dim, k, depth + 1), 
                             findMinimum(node->right, dim, k, depth + 1)));
}
// Handles the request of find minimum point using given dimensions
void minimum(struct KTree *tree, int dim)
{
	if (tree->root == NULL)
	{
		printf("\n Empty Tree");
	}
	else if (dim < 0 || dim + 1 > tree->k)
	{
		printf("\n Given dimensions are not valid ");
	}
	else
	{
		int ans = findMinimum(tree->root, dim, tree->k, 0);
		printf("\n Given Dimension : %d", dim);
		printf("\n Minimum is : %d", ans);
	}
}
int main(int argc, char
	const *argv[])
{
	// Number of Dimensions
	int k = 2;
	struct KTree *tree = createTree(k);
	// 2d points
	int data[][2] = {
		{
			8 , 9
		},
		{
			7 , 6
		},
		{
			3 , 9
		},
		{
			11 , 12
		},
		{
			2 , 8
		},
		{
			9 , 4
		},
		{
			10 , 13
		},
		{
			14 , 8
		}
	};
	// 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, 9)
	    /      \
	  (7,6)    (11,12)     
	     \      /    \
	     (3,9)(9,4)  (10,13)
		/        \
	  (2,8)      (14,8)          
	-----------------
	Developed tree
	*/
	// Print  tree elements in inorder  form
	printTree(tree->root, tree->k);
	minimum(tree, 1);
	minimum(tree, 0);
	return 0;
}

Output

 Tree Nodes
 ( 7 , 6)
 ( 2 , 8)
 ( 3 , 9)
 ( 8 , 9)
 ( 9 , 4)
 ( 14 , 8)
 ( 11 , 12)
 ( 10 , 13)

 Given Dimension : 1
 Minimum is : 4
 Given Dimension : 0
 Minimum is : 2