Delete sorted sequence in Binary Search Tree

//C Program 
//Delete sorted sequence 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 binary_search(int *arr,int size,int element)
{

  if(size <= 1) return -1;

  int i=0, j = (size-1),mid=0;
 
  //base condition
  while(j > i && arr[i] != element && arr[j] != element)
  {
    //Get middle element
    mid = (i+j)/2;

    if(arr[mid] > element)
    {
      //When middle element of index i and j are greater
      j = mid-1;
    }
    else if(arr[mid] < element)
    {
      //When middle element of index i and j are less
      i = mid+1;
    }
    else
    {
      //when get element
      i = mid;
      break;
    }
  }
  if(arr[i] == element )
  {
  
     return i;

  }
  else if(arr[j] == element )
  {
     return j;
  }
  return -1;
}
//Swap two nodes values
void swap_data(struct Node*root1, struct Node*root2)
{
  int temp=root1->data;
  root1->data=root2->data;
  root2->data=temp;
}
struct Node* delete_elements(struct Node*root,
 struct Node*left_side,
 struct Node*right_side,
 int collection[],
 int size
 )
{
  if(root != NULL)
  {

   root->left = delete_elements(root->left,left_side,root,collection,size);
   root->right = delete_elements(root->right,root,right_side,collection,size);
   
   if(binary_search(collection,size,root->data)!=-1)
   {
     
     if(root->left == NULL && root->right == NULL )
     {
      //Delete leaf node
      free(root);
      root=NULL;
     }
     else if(root->left == NULL)
     {
       right_side=root->right;
       free(root);
       root=right_side;
     }
     else if(root->right==NULL)
     {
        left_side=root->left;
       free(root);
       root=left_side;
     }
   }
   else if(left_side != NULL && binary_search(collection,size,left_side->data)!=-1)
   {

     //Swap element values
     swap_data(left_side,root);
     right_side=root->right;
     free(root);
     root=right_side;

   } 
   else if(right_side != NULL && binary_search(collection,size,right_side->data)!=-1)
   {
    //swap element values
     swap_data(right_side,root);
     left_side=root->left;
     free(root);
     root=left_side;
   }
  }

  return root;
}
struct Node* delete_collection(struct Node*root,
  int collection[],
  int size)
{
  if(root != NULL)
  {
    
   return delete_elements(root,NULL,NULL,collection,size);

  }
  else
  {
    printf("Empty BST\n");
    return NULL;
  }
 
}

void preorder(struct Node*root)
{
  if(root!=NULL)
  {
    printf("%3d ",root->data );
    preorder(root->left);

    preorder(root->right);
  }
}
int main(){
    
  struct Node*root = NULL;

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


  */                


    add(&root,5); 
    add(&root,3); 
    add(&root,9); 
    add(&root,1); 
    add(&root,4); 
    add(&root,8); 
    add(&root,11); 
    add(&root,-3); 
    add(&root,2); 
    add(&root,7); 
    add(&root,12); 
    preorder(root);//Before Delete

    int sort_collection[]={1,5,7,9,12};

    int size = sizeof(sort_collection)/sizeof(sort_collection[0]);
  
    root=delete_collection(root,sort_collection,size);
   
    printf("\n");
    preorder(root);//After Delete


  return 0;
}

Output

  5   3   1  -3   2   4   9   8   7  11  12 
  4   3  -3   2   8  11