Find distance between two nodes of a Binary Search Tree

//C Program 
//Find distance between two nodes of a Binary Search Tree
#include <stdio.h>

#include <stdlib.h>
 //structure of Binary Search Tree node
struct Node
{
	int data;
	struct Node *left, *right;
};
//Adding a new node in binary search tree
void add(struct Node **root, int data)
{
	//Create a dynamic node of binary search tree 
	struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
	if (new_node != NULL)
	{
		//Set data and pointer values
		new_node->data = data;
		new_node->left = NULL; //Initially node left-pointer is NULL
		new_node->right = NULL; //Initially node right-pointer is NULL
		if ( *root == NULL)
		{
			//When adds a first node in binary tree
			*root = new_node;
		}
		else
		{
			struct Node *find = *root;
			//iterate binary tree and add new node to proper position
			while (find != NULL)
			{
				if (find->data > data)
				{
					if (find->left == NULL)
					{
						find->left = new_node;
						break;
					}
					else
					{ //visit left sub-tree
						find = find->left;
					}
				}
				else
				{
					if (find->right == NULL)
					{
						find->right = new_node;
						break;
					}
					else
					{
						//visit right sub-tree
						find = find->right;
					}
				}
			}
		}
	}
	else
	{
		printf("Memory Overflow\n");
		exit(0); //Terminate program execution
	}
}
//Check that whether given binary tree node exists in BST
struct Node *find_node(struct Node *root, int data)
{
	if (root != NULL)
	{
		if (root->data > data)
		{
			return find_node(root->left, data);
		}
		else if (root->data < data)
		{
			return find_node(root->right, data);
		}
		else
		{
			return root;
		}
	}
	return NULL;
}
//Find LCA (parent node) of two given binary tree node
struct Node *lca(struct Node *root, int first, int second)
{
	if (root != NULL)
	{
		if (root->data > first && root->data > second)
		{
			return lca(root->left, first, second);
		}
		else if (root->data < first && root->data < second)
		{
			return lca(root->right, first, second);
		}
		else
		{
			return root;
		}
	}
	return NULL;
}
//Returns the calculating result of path length between given head to tree element
int count_path(struct Node *root, int element)
{
	int counter = 0;
	while (root != NULL)
	{
		if (root->data > element)
		{
			root = root->left;
		}
		else if (root->data < element)
		{
			root = root->right;
		}
		else
		{
			break;
		}
		counter++;
	}
	return counter;
}
//This function are handle the request of finding length distance of two given binary tree nodes
void path_length(struct Node *root, int first, int second)
{
	if (root != NULL)
	{
		//First we are check that given elements are exist or not in BST
		struct Node *node1 = find_node(root, first);
		struct Node *node2 = find_node(root, second);
		if (node1 != NULL && node2 != NULL)
		{
			//When both node are exist
			//Find LCA of two nodes
			struct Node *head = lca(root, first, second);
			int result = 0;
			if (head->data == first)
			{
				//When head is current (first key) node 
				//And need to finding the path between [first key->second key nodes]
				result = count_path(head, second);
			}
			else if (head->data == second)
			{
				//When head is current (second key) node 
				//And need to finding the path between [second key->first key nodes]
				result = count_path(head, first);
			}
			else
			{
				//When first and second is child node of LCA of head node
				result = count_path(head, first) + count_path(head, second);
			}
			printf("Path Length between nodes [%d %d] is : %d\n", first, second, result);
		}
		else
		{
			printf("Node pair [%d %d] are missing\n",first, second);
		}
	}
	else
	{
		printf("\nEmpty BST");
	}
}
int main()
{
	struct Node *root = NULL;
	//Add nodes in binary search tree
	/*
         10
       /   \
      3     19
     / \   /  \
    1   4  14  50
   / \     
 -3   2          

  */
	add( & root, 10);
	add( & root, 3);
	add( & root, 19);
	add( & root, 1);
	add( & root, 4);
	add( & root, -3);
	add( & root, 2);
	add( & root, 14);
	add( & root, 50);
	//Test case
	path_length(root, 2, 14);
	path_length(root, -3, 4);
	path_length(root, 10, 2);
	path_length(root, 3, 2);
	path_length(root, 3, 3);
  	path_length(root, 3, 9);
	return 0;
}

Output

Path Length between nodes [2 14] is : 5
Path Length between nodes [-3 4] is : 3
Path Length between nodes [10 2] is : 3
Path Length between nodes [3 2] is : 2
Path Length between nodes [3 3] is : 0
Node pair [3 9] are missing