Binary Tree - Modular code

//basic.h

#ifndef BASIC_H
#define BASIC_H
#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#include <math.h>
#include <string.h>

typedef int element;

typedef struct item {
    element value;
    struct item *left, *right;
} node;

typedef node* tree;

extern bool empty(tree t);
extern tree emptyTree();
extern element root(tree t);
extern tree left(tree t);
extern tree right(tree t);
extern void showElement(element e);
extern tree consTree(element e, tree l, tree r);
extern bool isLess(element lhs, element rhs);
extern bool isEqual(element lhs, element rhs);
extern bool isGreater(element lhs, element rhs);
extern void destroyTree(tree t);
extern tree find(element e, tree t);
extern void preOrder(tree t);
extern void postOrder(tree t);
extern void inOrder(tree t);
extern bool booleanSearch(element e, tree t);
extern tree find(element e, tree t);
extern uint32_t height(tree t);
extern void deleteElement(element e, tree t);

//BST (Binary Search Tree) algorithms
extern tree insOrdTree(element e, tree t);

#endif /*!BASIC_H*/

//basic.c

bool isEqual(element lhs, element rhs)
{
    return lhs == rhs;
}

bool isLess(element lhs, element rhs)
{
    return lhs < rhs;
}

bool isGreater(element lhs, element rhs)
{
    return !isLess(lhs, rhs) && !isEqual(lhs, rhs);
}

bool empty(tree t)
{
    return (t == NULL);
}

tree emptyTree()
{
    return NULL;
}

element root(tree t)
{
    if (empty(t)) abort();
    return t->value;
}

tree left(tree t)
{
    if (empty(t)) abort();
    return t->left;
}

tree right(tree t)
{
    if (empty(t)) abort();
    return t->right;
}

tree consTree(element e, tree l, tree r)
{
    tree t = malloc(sizeof(node));
    t->value = e;
    t->left = l;
    t->right = r;

    return t;
}

void showElement(element e)
{
    printf("%d", e);
}

void preOrder(tree t)
{
    if (!empty(t))
    {
        printf("\t");
        showElement(root(t));
        preOrder(left(t));
        preOrder(right(t));
    }
}

void postOrder(tree t)
{
    if (!empty(t))
    {
        postOrder(left(t));
        postOrder(right(t));
        printf("\t");
        showElement(root(t));
    }
}

void inOrder(tree t)
{
    if (!empty(t))
    {
        inOrder(left(t));
        printf("\t");
        showElement(root(t));
        inOrder(right(t));
    }
}

bool booleanSearch(element e, tree t)
{
    if (empty(t)) return false;

    if (isEqual(root(t), e)) return true;
    else
        return (booleanSearch(e, left(t)) || booleanSearch(e, right(t)));
}

void destroyTree(tree t)
{
    if (!empty(t))
    {
        tree l = left(t), r = right(t);
        free(t);
        destroyTree(l); destroyTree(r);
    }
}

tree find(element e, tree t)
{
    if (!empty(t))
    {
        if (isEqual(root(t), e)) return t;

        tree l = find(e, left(t));
        if (!empty(l)) return l;

        tree r = find(e, right(t));
        if (!empty(r)) return r;
        else
            return emptyTree();

    }
    else
        return emptyTree();
}

uint32_t height(tree t)
{
    if (empty(t)) return 0;
    else
    {
        uint32_t hl = height(left(t)),
            hr = height(right(t));
        return 1 + (hl>hr ? hl : hr);
    }
}

tree insOrdTree(element e, tree t)
{
    if (empty(t))
        return consTree(e, emptyTree(), emptyTree());
    else
        if (isLess(e, root(t)) || isEqual(e, root(t)))
            return consTree(root(t), insOrdTree(e, left(t)), right(t));
        else
            return consTree(root(t), left(t), insOrdTree(e, right(t)));
}

void deleteElement(element e, tree t)
{
    tree l = t, fl = emptyTree(), fr = emptyTree();

    while (root(t) != e && !empty(t))
    {
        if (root(t) <= e)
        {
            fr = t;
            fl = emptyTree();
            t = right(t);
        }
        else
        {
            fl = t;
            fr = emptyTree();
            t = left(t);
        }
    }

    if (!empty(left(t)) && !empty(right(t)))
    {
        fr = t;
        fl = emptyTree();
        tree next = right(t);
        if (!empty(next))
            while (!empty(left(next)))
            {
                fr = emptyTree();
                fl = next;
                next = left(next);
            }
        t->value = root(next);

        next = (!empty(right(next))) ? right(next) : emptyTree();

        if (!empty(fl))
            fl->left = next;
        else
            fr->right = next;
    }
}

int main(void)
{
    return EXIT_SUCCESS;
}