Floor value in binary search tree

/*
    C program for
    Floor 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;
}
// 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;
				}
			}
		}
	}
}
// 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);
	}
}
int floorValue(struct TreeNode *node, int key)
{
	if (node == NULL)
	{
		return INT_MAX;
	}
	if (node->data == key)
	{
		// When given key is equal to node data
		return node->data;
	}
	if (node->data > key)
	{
		// Visit left subtree
		return floorValue(node->left, key);
	}
	// Find floor in right subtree
	int x = floorValue(node->right, key);
	if (x <= key)
	{
		return x;
	}
	return node->data;
}
void floorOfKey(struct TreeNode *root, int key)
{
	if (root == NULL)
	{
		return;
	}
	// Display the floor of given key
	printf("\n floor of %d is : %d", key, floorValue(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
	floorOfKey(tree->root, 6);
	floorOfKey(tree->root, 25);
	floorOfKey(tree->root, 17);
	floorOfKey(tree->root, 2);
	floorOfKey(tree->root, 43);
	return 0;
}

Output

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