Árbol binario de búsqueda con operaciones básicas en C

El siguiente código es un programa de ejemplo que maneja un árbol binario de búsqueda con las operaciones insertar, borrar y buscar un elemento. En este caso maneja números enteros.

//Programa 1a. Operaciones con un ABB

#include <stdio.h>

#include <stdlib.h>

struct Nodo

    {

    int dato;

    struct Nodo *izdo, *dcho;
};

typedef struct Nodo elementoArbol;

typedef elementoArbol* arbolBin;

//prototipos

elementoArbol* buscar(elementoArbol* p, int buscado);

void insertar(elementoArbol** raiz, int nuevoDato);

void preorden(elementoArbol* raiz);

void enorden(elementoArbol* raiz);

void postorden(elementoArbol* raiz);

void eliminar(elementoArbol** raiz, int clave);

void reemplazar(elementoArbol** act);

void recorridos(elementoArbol* raiz);

void menu(void);

void liberar(elementoArbol* raiz);

int main()

{

    //creando arbol

    elementoArbol* arbol = NULL;

    int x = 0;

    do

    {

        menu();

        scanf("%d", &x);

        switch (x)

        {

        case 1:

        {

            int y = 0;

            printf("Valor a insertar: ");

            scanf("%d", &y);

            if (buscar(arbol, y))

                printf("EL ELEMENTO YA SE ENCUENTRA\n");

            else

                insertar(&arbol, y);

            recorridos(arbol);

            break;
        }

        case 2:

        {

            int y = 0;

            printf("Valor a eliminar: ");

            scanf("%d", &y);

            eliminar(&arbol, y);

            recorridos(arbol);

            break;
        }

        case 3:

        {

            int y = 0;

            printf("Valor a buscar: ");

            scanf("%d", &y);

            if (!buscar(arbol, y))

                printf("EL ELEMENTO NO SE ENCUENTRA\n");

            recorridos(arbol);

            break;
        }

        case 4:

        {

            liberar(arbol);

            exit(0);

            break;
        }

        default:

        {

            printf("Escoja un valor entre 1 y 4\n");
        }
        }

        fflush(stdin);

    } while (x != 4);

    return 0;
}

//----------------------------------------------------------------------

//crea un nodo

arbolBin crearNodo(int x)

{

    arbolBin a;

    a = (arbolBin)malloc(sizeof(elementoArbol));

    a->dato = x;

    a->dcho = a->izdo = NULL;

    return a;
}

//busca un nodo

elementoArbol* buscar(elementoArbol* p, int buscado)

{

    if (!p)

    {

        return 0;
    }

    else if (buscado == p->dato)

    {

        printf("EL ELEMENTO SI EXISTE\n");

        return p;
    }

    else if (buscado < p->dato)

        return buscar(p->izdo, buscado);

    else

        return buscar(p->dcho, buscado);
}

//inserta un nodo

void insertar(elementoArbol** raiz, int nuevoDato)

{

    if (!(*raiz))

        *raiz = crearNodo(nuevoDato);

    else if (nuevoDato < (*raiz)->dato)

        insertar(&((*raiz)->izdo), nuevoDato);

    else

        insertar(&((*raiz)->dcho), nuevoDato);

    return;
}

//recorrido preorden

void preorden(elementoArbol* raiz)

{

    if (raiz != NULL)

    {

        printf("%d ", raiz->dato);

        preorden(raiz->izdo);

        preorden(raiz->dcho);
    }

    return;
}

//recorrido enorden

void enorden(elementoArbol* raiz)

{

    if (raiz != NULL)

    {

        enorden(raiz->izdo);

        printf("%d ", raiz->dato);

        enorden(raiz->dcho);
    }

    return;
}

//recorrido postorden

void postorden(elementoArbol* raiz)

{

    if (raiz != NULL)

    {

        postorden(raiz->izdo);

        postorden(raiz->dcho);

        printf("%d ", raiz->dato);
    }

    return;
}

//eliminar un nodo

void eliminar(elementoArbol** raiz, int clave)

{

    if (!(*raiz))

        printf("EL ELEMENTO NO SE ENCUENTRA\n");

    else if (clave < (*raiz)->dato)

        eliminar(&(*raiz)->izdo, clave);

    else if (clave > (*raiz)->dato)

        eliminar(&(*raiz)->dcho, clave);

    else

    {

        elementoArbol* q;

        q = (*raiz);

        if (q->izdo == NULL)

            (*raiz) = q->dcho;

        else if (q->dcho == NULL)

            (*raiz) = q->izdo;

        else

        {

            reemplazar(&q);
        }

        free(q);
    }

    return;
}

//reemplazar

void reemplazar(elementoArbol** act)

{

    elementoArbol *a, *p;

    p = *act;

    a = (*act)->izdo;

    while (a->dcho)

    {

        p = a;

        a = a->dcho;
    }

    (*act)->dato = a->dato;

    if (p == (*act))

        p->izdo = a->izdo;

    else

        p->dcho = a->izdo;

    (*act) = a;

    return;
}

//reailiza recorridos

void recorridos(elementoArbol* raiz)

{

    preorden(raiz);

    printf("\n");

    enorden(raiz);

    printf("\n");

    postorden(raiz);

    printf("\n");

    return;
}

//menu

void menu(void)

{

    printf("1. Insertar un elemento\n");

    printf("2. Eliminar un elemento\n");

    printf("3. Buscar un elemento\n");

    printf("4. Salir del programao\n\n");

    return;
}

//liberar memoria arbol

void liberar(elementoArbol* raiz)

{

    if (raiz != NULL)

    {

        liberar(raiz->izdo);

        liberar(raiz->dcho);
    }

    free(raiz);

    return;
}