Delete a node in binary tree

/*
  C Program 
+ Delete a node in binary tree
*/
#include<stdio.h>

#include<stdlib.h>
 //structure of Binary Tree node
struct Node {
  int data;
  struct Node *left, *right;
};
//Create a binary tree nodes and node fields (data,pointer) 
//And returning the reference of newly nodes

struct Node *insert(int data) {
  //create dynamic memory to new binary tree node
  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
  } else {
    printf("Memory Overflow\n");
    exit(0); //Terminate program execution
  }
  //return reference
  return new_node;

}

//Find deleted node
void find(struct Node *root, struct Node *parent, int element, struct Node **result) {

  if (root != NULL && *result == NULL) {
    if (element == root->data) {
      *result = parent;
      return;
    }
    find(root->left, root, element, result);
    find(root->right, root, element, result);
  }

}
struct Node *getNode(struct Node *root) {
  //Replace root with any node
  //Either delete last node of tree
  //Or delete any node which are zero or have one child node
  struct Node *auxiliary = root, *temp = NULL;

  while (auxiliary->left != NULL) {
    temp = auxiliary;
    auxiliary = auxiliary->left;
  }

  temp->left = auxiliary->right;
  auxiliary->right = NULL;

  //change data
  (root)->data = auxiliary->data;

  return auxiliary;
}
void deleteNode(struct Node **root, int element) {

  if ( *root == NULL) return;

  struct Node *auxiliary = NULL, *head = NULL;

  if (( *root)->data == element) {
    //Delete root

    auxiliary = ( *root);

    if (( *root)->left == NULL) {
      //When no left sub tree
      ( *root) = ( *root)->right;
    } else if (( *root)->right == NULL) {
      //When no right sub tree
      ( *root) = ( *root)->left;
    } else {
      auxiliary = getNode( *root);
    }
  } else {
    //Find parent of deleted node
    find( *root, *root, element, & head);

    if (head != NULL) {
      //When deleted node are exist

      if (head->left != NULL && head->left->data == element) {
        auxiliary = head->left;

        if (auxiliary->left == NULL) {
          head->left = auxiliary->right;
        } else if (auxiliary->right == NULL) {
          head->left = auxiliary->left;
        } else {
          auxiliary = getNode(auxiliary);
        }

      } else if (head->right != NULL && head->right->data == element) {
        auxiliary = head->right;

        if (auxiliary->left == NULL) {
          head->right = auxiliary->right;
        } else if (auxiliary->right == NULL) {
          head->right = auxiliary->left;
        } else {
          auxiliary = getNode(auxiliary);
        }
      }

    }
  }

  if (auxiliary != NULL) {
    printf("\n Delete : %d ", element);
    free(auxiliary);
    auxiliary = NULL;
  } else {
    printf("\n Delete node %d is not found", element);
  }
  printf("\n");
}

//Display tree element inorder form
void inorder(struct Node *node) {

  if (node != NULL) {

    inorder(node->left);
    //Print node value
    printf("  %d", node->data);
    inorder(node->right);
  }
}
int main() {

  struct Node *root = NULL;
  /* Make A Binary Tree
  -----------------------
          1
         /  \
        2    3
       /    /  \
      6    5    4
       \       /
        8     7 
  */
  //Insertion of binary tree nodes
  root = insert(1);
  root->left = insert(2);
  root->right = insert(3);
  root->right->right = insert(4);
  root->right->right->left = insert(7);
  root->right->left = insert(5);
  root->left->left = insert(6);
  root->left->left->right = insert(8);
  //Display Tree elements
  inorder(root);

  //Test case
  deleteNode( & root, 6);
  inorder(root);

  deleteNode( & root, 1);
  inorder(root);

  deleteNode( & root, 4);
  inorder(root);


  deleteNode( & root, 3);
  inorder(root);


  deleteNode( & root, 3);
  inorder(root);
  return 0;
}

Output

  6  8  2  1  5  3  7  4
 Delete : 6 
  8  2  1  5  3  7  4
 Delete : 1 
  2  8  5  3  7  4
 Delete : 4 
  2  8  5  3  7
 Delete : 3 
  2  8  5  7
 Delete node 3 is not found
  2  8  5  7