Estrutura de Dados - Arvore BST - I/R

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

/*
/@autor: Shouldz
/@Linguagem: C
/@Descrição: [Estrutura de Dados] Árvore BST com operação de inserção e remoção funcionais, ambas recursivas.
*/

typedef struct no{
    int valor;
    struct no *dir;
    struct no *esq;
}no;

no *criar_no(int valor){
    no *criar_no = malloc(sizeof(no));
    criar_no -> dir = NULL;
    criar_no -> esq = NULL;
    criar_no -> valor = valor;
    return criar_no;
}

no *inserir(no *raiz, int valor){
    if(raiz == NULL){
        raiz = criar_no(valor);
        return raiz;
    }else{
        if(valor > raiz -> valor){
            raiz -> dir = inserir(raiz -> dir, valor);
        }else{
            raiz -> esq = inserir(raiz -> esq, valor);
        }
    }
}

no *maiorDescendenteEsquerdo(no *raiz){
    //Procura o maior descendente esquerdo do elemento a ser removido
    no *auxiliar = raiz;
    //Se a subarvore esquerda do elemento não tem direito, então maior encontrado
    if(auxiliar -> dir == NULL){
        return auxiliar;
    }else{
        //se tem direito, então percorrer todas as subarvores direitas afim do maior
        while(auxiliar -> dir != NULL){
            auxiliar = auxiliar -> dir;
        }
        return auxiliar;
    }
}

no *remover(no *raiz, int valor){
    //caso base
    if(raiz == NULL){
        return NULL;
    }
    //if e elif para procurar o elemento
    if(valor > raiz -> valor){
        raiz -> dir = remover(raiz -> dir, valor);
    }else if(valor < raiz -> valor){
        raiz -> esq = remover(raiz -> esq, valor);
    }else{ //caso encontrado
        //caso 01 e 02: No possui um ou nenhum filho
        if(raiz -> dir == NULL){
            no *auxiliarE = raiz -> esq;
            return auxiliarE;
        }else if(raiz -> esq == NULL){
            no *auxiliarD = raiz -> dir;
            return auxiliarD;
        }
        //caso 03: No possui 3 filhos, uso da função para achar maiorDescendenteEsquerdo
        no *receber = maiorDescendenteEsquerdo(raiz -> esq);
        //copia o valor do maiorDescendenteEsquerdo
        raiz -> valor = receber -> valor;
        //remover o elemento copiado
        raiz -> esq = remover(raiz -> esq, receber -> valor);
    }
    return raiz;
}
void preorder(no *arvore){
    if(arvore != NULL){
        printf("[%d]", arvore -> valor);
        preorder(arvore -> esq);
        preorder(arvore -> dir);
    }
}

void main(){
    no *arvore = NULL;
    printf("TESTE 01: R= 70\n");
    arvore = inserir(arvore, 40);
    arvore = inserir(arvore, 12);
    arvore = inserir(arvore, 65);
    arvore = inserir(arvore, 10);
    arvore = inserir(arvore, 70);
    preorder(arvore);
    printf("\n");
    arvore = remover(arvore, 70);
    preorder(arvore);
    printf("\n");
    arvore = NULL;
    printf("TESTE 02: R= 65\n");
    arvore = inserir(arvore, 40);
    arvore = inserir(arvore, 12);
    arvore = inserir(arvore, 65);
    arvore = inserir(arvore, 10);
    arvore = inserir(arvore, 70);
    preorder(arvore);
    printf("\n");
    arvore = remover(arvore, 65);
    preorder(arvore);
    printf("\n");
    arvore = NULL;
    printf("TESTE 03: R= 12\n");
    arvore = inserir(arvore, 40);
    arvore = inserir(arvore, 12);
    arvore = inserir(arvore, 65);
    arvore = inserir(arvore, 10);
    arvore = inserir(arvore, 15);
    arvore = inserir(arvore, 70);
    arvore = inserir(arvore, 8);
    arvore = inserir(arvore, 11);
    preorder(arvore);
    printf("\n");
    arvore = remover(arvore, 12);
    preorder(arvore);
}