Delete a path from given node to root node in BST

//C Program 
//Delete a path from given node to root node 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 swap_data(struct Node*root1,struct Node*root2)
{
  int temp=root2->data;
  root2->data=root1->data;
  root1->data=temp;
}
struct Node* delete_path(struct Node*root,int key)
{
  if(root != NULL)
  {
    if(root -> data > key)
    {
      root->left = delete_path(root->left,key);
    }
    else if(root->data < key)
    {
      root->right = delete_path(root->right,key);
    }
    struct Node*temp=NULL,*back=NULL;
    if(root->left==NULL)
    {
      temp=root;
      root=root->right;
    }
    else if(root->right==NULL)
    {
      temp=root;
      root=root->left;
    }
    else
    {
      temp=root->left;
      back=temp;

      while(temp->right!=NULL)
      {
        back=temp;
        temp=temp->right;
      }
      if(root->left==temp)
      {
        swap_data(root,temp);
        root->left=temp->left;
      }
      else
      {
        swap_data(root,temp);
        back->right=temp->left;
      }
    }

    if(temp!=NULL)
    {
      free(temp);
      temp=NULL;
    }
  }
  return root;
}
struct Node* find_node(struct Node*root,int key)
{
  if(root != NULL)
  {
    if(root -> data==key)
    {
      //when leaf node exist
      return root;
    }
    else if(root -> data > key)
    {
      return find_node(root->left,key);
    }
    else 
    {
      return find_node(root->right,key);
    }
  }
  return NULL;
}

struct Node* delete_node(struct Node*root,int key)
{
  if(root!=NULL)
  {

    if(find_node(root,key) != NULL)
    {
      root=delete_path(root,key);
    }
    else
    {
      printf("\n  Given node %d are not exist\n",key);
    }

  }
  else
  {
    printf("\n  Empty BST\n");
  }
  printf("\n");
  return root;
}
void inorder(struct Node*root)
{
  if(root!=NULL)
  {

    inorder(root->left);
    printf("%3d ",root->data );
    inorder(root->right);
  }
}
int main(){

  struct Node*root = NULL;

  //Add nodes in binary search tree
  /*
              5
            /   \ 
           /     \
          3       19
         / \     /   \
        2   4   8     31
       /       / \    /
      1       7   15  25   


  */                

  add(&root,5); 
  add(&root,3); 
  add(&root,19); 
  add(&root,2); 
  add(&root,4); 
  add(&root,8); 
  add(&root,31); 
  add(&root,1); 
  add(&root,7); 
  add(&root,25); 
  add(&root,15); 


  inorder(root);

  root=delete_node(root,31);
  inorder(root);
  return 0;
}

Output

  1   2   3   4   5   7   8  15  19  25  31 
  1   2   3   4   7   8  15  25