A binary search tree implementation on C using Void pointer, which includes operations such as insertion, search, deletion

main.c

#include <stdio.h>
#include <stdlib.h>
#include "tree.h"

Bool is_greater(Element data1, Element data2)
{
  return *(int *)data1 > *(int *)data2 ? True : False;
}

Bool is_equal(Element data1, Element data2)
{
  return *(int *)data1 == *(int *)data2 ? True : False;
}

int lesser_or_equal(Element node1, Element node2)
{
  int number1 = *(int *)node1;
  int number2 = *(int *)node2;
  if (number1 == number2)
    return 1;
  if (number1 < number2)
    return -1;
  return 0;
}

void print_numbers(Element value)
{
  printf("%d ", *(int *)value);
}

int main(void)
{
  int numbers[] = {5, 3, 8, 1, 4, 7, 9, 2, 12, 17, 13, 19};
  int length = sizeof(numbers) / sizeof(int);
  Node_ptr tree = NULL;
  for (int index = 0; index < length; index++)
  {
    int *number_ptr = malloc(sizeof(int));
    *number_ptr = numbers[index];
    tree = insert_to_tree(tree, is_greater, number_ptr);
  }
  print_in_order(tree, print_numbers);
  printf("\n");
  print_pre_order(tree, print_numbers);
  printf("\n");
  print_post_order(tree, print_numbers);
  printf("\n");

  int *searching_number = malloc(sizeof(int));
  *searching_number = 19;

  print_presence(search(tree, lesser_or_equal, searching_number));
  delete_node(tree, lesser_or_equal, searching_number);
  print_two_dimensional(tree, print_numbers, 0);
  free(searching_number);
  destroy_tree(tree);

  return 0;
}

tree.c

#include <stdio.h>
#include <stdlib.h>
#include "tree.h"

Node_ptr create_node(Element value)
{
  Node_ptr node = malloc(sizeof(Node));
  node->value = value;
  node->left = NULL;
  node->right = NULL;
  return node;
}

Node_ptr insert_to_tree(Node_ptr tree, Comparator comparator, Element value)
{
  if (tree == NULL)
    return create_node(value);
  if (comparator(tree->value, value))
  {
    tree->left = insert_to_tree(tree->left, comparator, value);
    return tree;
  }
  tree->right = insert_to_tree(tree->right, comparator, value);
  return tree;
};

void print_in_order(Node_ptr tree, Printer printer)
{
  if (tree == NULL)
    return;
  print_in_order(tree->left, printer);
  printer(tree->value);
  print_in_order(tree->right, printer);
};

void print_pre_order(Node_ptr tree, Printer printer)
{
  if (tree == NULL)
    return;
  printer(tree->value);
  print_pre_order(tree->left, printer);
  print_pre_order(tree->right, printer);
};

void print_post_order(Node_ptr tree, Printer printer)
{
  if (tree == NULL)
    return;
  print_post_order(tree->left, printer);
  print_post_order(tree->right, printer);
  printer(tree->value);
};

Bool search(Node_ptr tree, LesserOrEqual comparator, Element value)
{
  if (tree == NULL)
    return False;
  if (comparator(tree->value, value) == 1)
    return True;
  if (comparator(value, tree->value) == -1)
    return search(tree->left, comparator, value);
  return search(tree->right, comparator, value);
}

void print_presence(Bool result)
{
  if (result == True)
  {
    printf("Present\n");
    return;
  }
  printf("Not Present\n");
}

void destroy_node(Node_ptr node)
{
  free(node->value);
  free(node);
}

void destroy_tree(Node_ptr tree)
{
  if (tree == NULL)
    return;
  Node_ptr left_tree = tree->left;
  Node_ptr right_tree = tree->right;
  destroy_node(tree);
  destroy_tree(left_tree);
  destroy_tree(right_tree);
}

Node_ptr find_min_node(Node_ptr root)
{
  return root->left == NULL ? root : find_min_node(root->left);
};

Node_ptr push_to_last_and_remove(Node_ptr tree, LesserOrEqual comparator)
{
  if (tree->left == NULL && tree->right == NULL)
    return NULL;
  if (tree->left == NULL)
  {
    Node_ptr temp = tree->right;
    destroy_node(tree);
    return temp;
  }
  if (tree->right == NULL)
  {
    Node_ptr temp = tree->left;
    destroy_node(tree);
    return temp;
  }

  Node_ptr min_node = find_min_node(tree->right);
  tree->value = min_node->value;
  tree->right = delete_node(tree->right, comparator, min_node->value);
  return tree;
};

Node_ptr delete_node(Node_ptr tree, LesserOrEqual comparator, Element value)
{
  if (tree == NULL)
    return NULL;
  if (comparator(value, tree->value) == -1)
  {
    tree->left = delete_node(tree->left, comparator, value);
    return tree;
  }
  if (comparator(value, tree->value) == 0)
  {
    tree->right = delete_node(tree->right, comparator, value);
    return tree;
  }
  return push_to_last_and_remove(tree, comparator);
};

void print_two_dimensional(Node_ptr root, Printer printer, int space)
{
  if (root == NULL)
    return;
  print_two_dimensional(root->right, printer, space + 10);
  printf("\n");
  for (int count = 0; count < space; count++)
  {
    printf(" ");
  }
  printer(root->value);
  printf("\n");
  print_two_dimensional(root->left, printer, space + 10);
}

tree.h

#ifndef __TREE_H_
#define __TREE_H_

typedef struct node
{
  void *value;
  struct node *left;
  struct node *right;
} Node;

typedef void *Element;

typedef Node *Node_ptr;

typedef enum
{
  False,
  True
} Bool;

typedef void (*Printer)(Element);
typedef Bool (*Comparator)(Element, Element);
typedef int (*LesserOrEqual)(Element, Element);

Bool search(Node_ptr tree, LesserOrEqual comparator, Element value);
Node_ptr push_to_last_and_remove(Node_ptr tree, LesserOrEqual comparator);
Node_ptr delete_node(Node_ptr tree, LesserOrEqual comparator, Element value);
Node_ptr insert_to_tree(Node_ptr tree, Comparator comparator, Element value);

void destroy_tree(Node_ptr tree);
void print_presence(Bool result);
void print_in_order(Node_ptr tree, Printer printer);
void print_pre_order(Node_ptr tree, Printer printer);
void print_post_order(Node_ptr tree, Printer printer);
void print_two_dimensional(Node_ptr root, Printer printer, int space);

#endif