Ceil value in binary search tree

/*
    C program for
    Ceil value in binary search tree
*/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

 // Tree Node
struct TreeNode
{
	int data;
	struct TreeNode *left;
	struct TreeNode *right;
};
// Binary Search Tree
struct BinarySearchTree
{
	struct TreeNode *root;
};
// Create new tree
struct BinarySearchTree *newTree()
{
	// Create dynamic node
	struct BinarySearchTree *tree = (struct BinarySearchTree *)
						malloc(sizeof(struct BinarySearchTree));
	if (tree != NULL)
	{
		tree->root = NULL;
	}
	else
	{
		printf("Memory Overflow to Create tree Tree\n");
	}
	// Return new tree
	return tree;
}
// This is creates and returns the new binary search tree node
struct TreeNode *getNode(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;
}
// Recursive function
// Display preorder view of binary search tree
void preorder(struct TreeNode *node)
{
	if (node != NULL)
	{
		// Print node value
		printf("  %d", node->data);
		preorder(node->left);
		preorder(node->right);
	}
}
// Adding a new node in binary search tree
void addNode(struct BinarySearchTree *tree, int data)
{
	struct TreeNode *node = getNode(data);
	if (node != NULL)
	{
		if (tree->root == NULL)
		{
			tree->root = node;
		}
		else
		{
			struct TreeNode *auxiliary = tree->root;
			// Add new node in binary search tree
			while (auxiliary != NULL)
			{
				if (data > auxiliary->data)
				{
					if (auxiliary->right == NULL)
					{
						// Add new node at right child
						auxiliary->right = node;
						return;
					}
					auxiliary = auxiliary->right;
				}
				else
				{
					if (auxiliary->left == NULL)
					{
						// Add new node at left child
						auxiliary->left = node;
						return;
					}
					auxiliary = auxiliary->left;
				}
			}
		}
	}
}
int ceilValue(struct TreeNode *node, int key)
{
	if (node == NULL)
	{
		return INT_MIN;
	}
	if (node->data == key)
	{
		// When given key is equal to node data
		return node->data;
	}
	if (node->data < key)
	{
		// Visit right subtree
		return ceilValue(node->right, key);
	}
	// Find ceil in left subtree
	int x = ceilValue(node->left, key);
	if (x >= key)
	{
		return x;
	}
	return node->data;
}
void ceilOfKey(struct TreeNode *root, int key)
{
	if (root == NULL)
	{
		return;
	}
	// Display the ceil of given key
	printf("\n Ceil of %d is : %d", key, ceilValue(root, key));
}
int main()
{
	struct BinarySearchTree *tree = newTree();
	/*
	         9                            
	       /   \    
	      3     17    
	     / \     \               
	    1   4     32
	   /     \    / 
	  -3      7  19
	-----------------
	    Binary Search Tree
	*/
	addNode(tree, 9);
	addNode(tree, 3);
	addNode(tree, 4);
	addNode(tree, 7);
	addNode(tree, 1);
	addNode(tree, -3);
	addNode(tree, 17);
	addNode(tree, 32);
	addNode(tree, 19);
	printf("\n Tree Element : ");
	preorder(tree->root);
	// Test Inputs
	ceilOfKey(tree->root, 6);
	ceilOfKey(tree->root, 25);
	ceilOfKey(tree->root, 17);
	ceilOfKey(tree->root, 2);
	ceilOfKey(tree->root, -5);
	return 0;
}

Output

 Tree Element :   9  3  1  -3  4  7  17  32  19
 Ceil of 6 is : 7
 Ceil of 25 is : 32
 Ceil of 17 is : 17
 Ceil of 2 is : 3
 Ceil of -5 is : -3