Count smaller elements on right side using binary search tree

/*
    C program for
    Count smaller elements on right side using binary search tree
*/
#include <stdio.h>
#include <stdlib.h>

// Tree Node
struct TreeNode
{
	int data;
	int count;
	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;
		// number of left child 
		node->count = 0;
	}
	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 and
// Returns the number of an element smaller than the given data
int smallerElement(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;
			int count = 0;
			// Add new node in binary search tree
			while (auxiliary != NULL)
			{
				if (data >= auxiliary->data)
				{
					// Update result counter
					if (auxiliary->data == data)
					{
						// When node are same
						count += auxiliary->count;
					}
					else
					{
						count += auxiliary->count + 1;
					}
					if (auxiliary->right == NULL)
					{
						// Add new node at right child
						auxiliary->right = node;
						return count;
					}
					auxiliary = auxiliary->right;
				}
				else
				{
					// Incress number of left child
					auxiliary->count += 1;
					if (auxiliary->left == NULL)
					{
						// Add new node at left child
						auxiliary->left = node;
						return count;
					}
					auxiliary = auxiliary->left;
				}
			}
		}
	}
	return 0;
}
// Display given array elements
void printRecord(int arr[], int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("  %d", arr[i]);
	}
}
int main()
{
	struct BinarySearchTree *tree = newTree();
	int arr[] = {
		6 , 2 , 1 , 0 , 2 , 7 , 4 , 0 , 1 , 7 , 3 , 9 , 8
	};
	// Get the number of elements
	int n = sizeof(arr) / sizeof(arr[0]);
	int result[n];
	// Inserting the node in binary search tree and
	// Count number of smaller element in right side
	for (int i = n - 1; i >= 0; --i)
	{
		result[i] = smallerElement(tree, arr[i]);
	}
	printf("\n Array  : ");
	printRecord(arr, n);
	printf("\n Result : ");
	printRecord(result, n);
	return 0;
}

Output

 Array  :   6  2  1  0  2  7  4  0  1  7  3  9  8
 Result :   8  4  2  0  2  4  3  0  0  1  0  1  0