Inorder predecessor and successor for a given key in BST

//C Program 
//Inorder predecessor and successor for a given key in BST
#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
  }

}
void find_element(struct Node*root,
  struct Node*left_p,
  struct Node*right_p,
  int element)
{
  
  if(root!=NULL)
  {
  
    find_element(root->left,left_p,root,element);

    find_element(root->right,root,right_p,element);

    //Predecessor Condition
    if(root->right == NULL && right_p != NULL && (right_p->data == element))
    {
      printf("Predecessor : %d ",root->data );
    }

    else if(root->left == NULL && left_p!=NULL && root->data == element)
    {
      printf("Predecessor : %d ",left_p->data );
    }
    else if(root->left == NULL && root->data == element && left_p == NULL)
    {
      printf("Predecessor : NULL ");
    }

    //Successor Condition
    if(root->left == NULL && left_p != NULL && left_p->data == element)
    {
      printf("Successor : %d ",root->data );
    }
    else if(root->right == NULL && right_p != NULL && root->data == element)
    {
      printf("Successor : %d ",right_p->data );
    }
    else if(root->right == NULL && right_p == NULL && root->data == element)
    {
      printf("Successor : NULL " );
    }
  }
 
 
}
void successor_predecessor(struct Node*root,int element)
{
  if(root != NULL)
  {
    
   struct Node*prev=NULL; 
   printf("\nNode : %d => ", element);
   find_element(root,NULL,NULL,element);
   
  }
}

int main(){
    
  struct Node*root = NULL;

  //Add nodes in binary search tree
  /*
              6
            /    \
           /      \
          3        9
         /  \      / \
        1    5    7   11
       / \   /     \    \
     -3  2  4       8   12


  */                


  add(&root,6); 
  add(&root,3); 
  add(&root,9); 
  add(&root,1); 
  add(&root,5); 
  add(&root,7); 
  add(&root,8); 
  add(&root,11); 
  add(&root,-3); 
  add(&root,2); 
  
  add(&root,12);
  add(&root,4);  

  successor_predecessor(root,3);
  successor_predecessor(root,6);
  successor_predecessor(root,12);
  successor_predecessor(root,7);
  successor_predecessor(root,-3);
  successor_predecessor(root,1);
    
  return 0;
}

Output

Node : 3 => Predecessor : 2 Successor : 4 
Node : 6 => Predecessor : 5 Successor : 7 
Node : 12 => Predecessor : 11 Successor : NULL 
Node : 7 => Successor : 8 Predecessor : 6 
Node : -3 => Predecessor : NULL Successor : 1 
Node : 1 => Predecessor : -3 Successor : 2