Find the closest element in Binary Search Tree

//C Program 
//Find the closest element in 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
  }

}

int find_difference(int a,int b)
{
   a=a-b;

  if(a<0)
  {
    a=-a;
  }
  return a;
}
//Get the minimum difference of  three nodes 
int compare_node(struct Node *head,
  struct Node *left_p,
  struct Node *right_p,
  int element)
{

  int result=0,a=0,b=0,c=0;

  if(left_p != NULL && right_p != NULL)
  {
    a=find_difference(left_p->data,element);
    b=find_difference(right_p->data,element);
    c=find_difference(head->data,element);
    //get min difference element

      if((a<b)&&(a<c))
    {
      result = left_p->data;
    }
    else if(b<c && b<a)
    {
      result = right_p->data ;
    }
    else
    {
      result=head->data;
    }
   
  }
  else if(left_p!=NULL)
  {
    a=find_difference(left_p->data,element);
    c=find_difference(head->data,element);
    if(c<a)
    {
      result = head->data;
    }
    else
    {
      result = left_p->data ;
    }
  

  }
  else if(right_p != NULL)
  {
    b=find_difference(right_p->data,element);
    c=find_difference(head->data,element);
  
    if(c<a)
    {
      result = head->data;
    }
    else
    {
      result = right_p->data ;
    }

  }
  else
  {
    result=head->data;
  }
  return result;
}
void find_node(struct Node *root,
  struct Node *left_p,
  struct Node *right_p,
  int element)
{

    if(root!=NULL)
    {
     
      if(root->data==element)
      {
        printf("Node %d closest element  %d\n",element ,root->data );
      }
      else if(root->data > element)
      {
        if(root->left!=NULL)
        {
          find_node(root->left,left_p,root,element);
        }
        else
        {
          int result=compare_node(root,left_p,right_p,element);
          printf("Node %d closest element  %d\n",element ,result );
        }
      }
      else
      {
        if(root->right!=NULL)
        {
          find_node(root->right,root,right_p,element);
        }
        else
        {
          int result=compare_node(root,left_p,right_p,element);
          printf("Node %d closest element  %d\n",element ,result );
        }
        
      }
    }
  


}
void find_elements(struct Node *root,int element)
{

  if(root!=NULL)
  {
     find_node(root,NULL,NULL,element);
  }
  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
  find_elements(root,4);
  find_elements(root,17);
  find_elements(root,11);
  find_elements(root,25);
  find_elements(root,16);


  return 0;
}

Output

Node 4 closest element  4
Node 17 closest element  19
Node 11 closest element  10
Node 25 closest element  19
Node 16 closest element  14