// Dado un arbol y una clave, se encarga de borrar el nodo que contiene
// dicha clave. Devuelve el dato del nodo borrado.
// si el nodo buscado no existe devuelve NULL.
void* abb_borrar(abb_t *arbol, const char *clave){
if (!arbol) return NULL;
if (!abb_pertenece(arbol, clave))
return NULL;
else
return abb_borrar_r(arbol->raiz, NULL, 0, clave, arbol);
}
void *abb_obtener(const abb_t *arbol, const char *clave){
if(!abb_pertenece(arbol,clave)){
return NULL;
}
void* dato = abb_obtener_auxiliar(arbol,arbol->raiz,clave);
return dato;
}
void *abb_borrar(abb_t *arbol, const char *clave){
if(!arbol->raiz)return NULL;
else if (!abb_pertenece(arbol,clave))return NULL;
void* dato;
if(!arbol->raiz->nodo_derecho && !arbol->raiz->nodo_izquierdo){
dato = arbol->raiz->dato;
free(arbol->raiz->clave);
free(arbol->raiz);
arbol->raiz = NULL; //lo agrege
}
else{
dato = abb_borrar_auxiliar(arbol,arbol->raiz,clave, NULL);
}
arbol->cantidad--;
return dato;
}
void pruebas_lista_alumno(){
printf("%s","~~~ CREAR ~~~");
int comparar(char *str1, char *str2){
return strncmp(str1, str2, 3);
}
abb_t *abb = abb_crear(abb_comparar_clave_t comparar, NULL);
print_test("abb vacio fue creado",true);
print_test("abb cantidad es igual 0", abb_cantidad(abb) == 0);
printf("%s","~~~ ARBOL ~~~");
int n1 = 7, n2 = 1, n3 = 3;
const char* c1 = "c1", c2 = "c2", c3 = "c3";
print_test("borrar c1 da NULL", abb_borrar(abb, c1) == NULL);
print_test("obtener c1 da NULL", abb_obtener(abb, c1) == NULL);
print_test("c1 pertenece es false", !abb_pertenece(abb, c1));
print_test("guardar n1 en c1", abb_guardar(abb, c1, &n1));
print_test("obteber c1 da n1", abb_obtener(abb, c1) == &n1);
print_test("cantidad es igual a 1", abb_cantidad(abb) == 1);
print_test("c1 pertenece es true", abb_pertenece(abb, c1));
print_test("borrar c1", abb_borrar(abb, c1));
print_test("obtener c1 da NULL", abb_obtener(abb, c1) == NULL);
print_test("c1 pertenece es false", !abb_pertenece(abb, c1));
print_test("cantidad es igual a 0", abb_cantidad(abb) == 0);
print_test("guardar n1 en c1", abb_guardar(abb, c1, &n1));
print_test("guardar n2 en c2", abb_guardar(abb, c2, &n2));
print_test("guardar n3 en c3", abb_guardar(abb, c3, &n3));
printf("%s","~~~ ITERADOR EXTERNO ~~~");
abb_iter_t *iter = abb_iter_crear(abb);
print_test("abb iter fue creado",true);
print_test("iter avanzar", abb_iter_in_avanzar(iter));
print_test("iter avanzar", abb_iter_in_avanzar(iter));
print_test("iter avanzar", abb_iter_in_avanzar(iter));
print_test("iter ver actual es c3", abb_iter_in_ver_actual(iter) == c3);
print_test("iter al final es false", !abb_iter_in_al_final(iter));
print_test("iter avanzar", abb_iter_in_avanzar(iter));
print_test("iter ver actual es NULL", abb_iter_in_ver_actual(iter) == NULL);
print_test("iter avanzar es false", !abb_iter_in_avanzar(iter));
print_test("iter al final", abb_iter_in_al_final(iter));
printf("%s","~~~ ITERADOR INTERNO~~~");
bool visitar(const char *clave, void *valor, void *extra){
if((clave == NULL) || (valor == NULL)){
return false;
}
valor++;
return true;
}
print_test("Se corre el iter interno (+1 a los valores)", abb_in_order(abb->raiz, visitar, NULL, true);
n1++, n2++, n3++;
print_test("obteber c1 da n1+1", abb_obtener(abb, c1) == &n1);
print_test("obteber c2 da n2+1", abb_obtener(abb, c2) == &n2);
print_test("obteber c3 da n3+1", abb_obtener(abb, c3) == &n3);
printf("%s","~~~ DESTRUIR ~~~");
abb_iter_in_destruir(iter);
print_test("El iterador fue destruido",true);
void abb_destruir(abb);
print_test("El arbol fue destruido",true);
}
/* PRUEBA_ABB */
void prueba_abb(void){
//~
//~ // DATOS ESTATICOS
char *val1 = "pez espada";
char *val2 = "puerco";
char *val3 = "carpintero";
char *val4 = "ornitorrinco";
char *val5 = "oso hormiguero";
char *val6 = "ballena franca";
char *val7 = "colibri";
char *val8 = "perro callejero";
char *val9 = "marsupial";
char *val10 = "mariposa";
char *val11 = "pavo real";
// Datos dinámicos tipo lista
lista_t* val12 = lista_crear();
lista_t* val13 = lista_crear();
lista_t* val14 = lista_crear();
lista_t* val15 = lista_crear();
lista_t* val16 = lista_crear();
lista_t* val17 = lista_crear();
lista_t* val18 = lista_crear();
lista_t* val19 = lista_crear();
lista_t* val20 = lista_crear();
lista_t* val21 = lista_crear();
lista_t* val22 = lista_crear();
lista_insertar_ultimo(val12, "a");
lista_insertar_ultimo(val12, "b");
lista_insertar_ultimo(val12, "c");
lista_insertar_ultimo(val13, "d");
lista_insertar_ultimo(val13, "e");
lista_insertar_ultimo(val14, "f");
lista_insertar_ultimo(val15, "g");
lista_insertar_ultimo(val16, "h");
lista_insertar_ultimo(val17, "i");
lista_insertar_ultimo(val17, "j");
lista_insertar_ultimo(val18, "k");
lista_insertar_ultimo(val19, "l");
lista_insertar_ultimo(val20, "m");
lista_insertar_ultimo(val22, "n");
lista_insertar_ultimo(val22, "o");
// Creo un arbol vacio
abb_t* arbol0 = abb_crear(*cmp, NULL);
print_test("Prueba arbol0 vacio: ", arbol0);
print_test("Cantidad de arbol0 es 0: ", abb_cantidad(arbol0) == 0);
// Guardo clave 5, pez espada en la raiz de arbol0
print_test("Guardo clave 52, pez espada en la raiz de arbol0: ", abb_guardar(arbol0, "52", val1));
print_test("El 52 pertenece", abb_pertenece(arbol0, "52"));
print_test("Cantidad de arbol0 es 1: ", abb_cantidad(arbol0) == 1);
// Guardo clave 2, puerco en arbol0. Debe guardarse en el hijo izquierdo de 5.
print_test("Guardo clave 2, puerco en arbol0: ", abb_guardar(arbol0, "2", val2));
print_test("El 2 pertenece", abb_pertenece(arbol0, "2"));
print_test("Cantidad de arbol0 es 2: ", abb_cantidad(arbol0) == 2);
// Guardo clave 33, carpintero en arbol0. Debe guardarse en el hijo derecho de 2.
print_test("Guardo clave 33, carpintero en arbol0: ", abb_guardar(arbol0, "33", val3));
print_test("El 33 pertenece", abb_pertenece(arbol0, "33"));
print_test("Cantidad de arbol0 es 3: ", abb_cantidad(arbol0) == 3);
// Guardo clave 99, ornitorrinco en arbol0. Debe guardarse en el hijo derecho de 5.
print_test("Guardo clave 99, ornitorrinco en arbol0: ", abb_guardar(arbol0, "99", val4));
print_test("El 99 pertenece", abb_pertenece(arbol0, "99"));
print_test("Cantidad de arbol0 es 4: ", abb_cantidad(arbol0) == 4);
// Guardo clave 2, oso hormiguero en arbol0. Debe reemplazar a (2, puerco).
print_test("Reemplazo dato de clave 2 por oso hormiguero en arbol0: ", abb_guardar(arbol0, "2", val5));
// La cantidad debe haber permanecido constante.
print_test("Cantidad de arbol0 es 4: ", abb_cantidad(arbol0) == 4);
//~
//~ // Busco clave 2
print_test("Busco clave 2 con abb_obtener, devuelve oso hormiguero: ", val5 == abb_obtener(arbol0, "2"));
//~ // Busco clave 111, no existe
print_test("Busco clave 111 con abb_obtener, devuelve NULL: ", NULL == abb_obtener(arbol0, "111"));
//~ // Busco clave 33
print_test("Busco clave 33 con abb_pertenece, devuelve true: ", abb_pertenece(arbol0, "33"));
puts("");
//~ // Busco clave 10, no pertenece
print_test("Busco clave 10 con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "10"));
//~
//~
// Borrar
print_test("Cantidad de arbol0 antes de borrar es 4: ", abb_cantidad(arbol0) == 4);
print_test("Borro nodo hoja, clave 33, devuelve el dato carpintero: ", abb_borrar(arbol0, "33") == val3);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "33"));
print_test("Cantidad de arbol0 despues de borrar es 3: ", abb_cantidad(arbol0) == 3);
print_test("Cantidad de hojas arbol0 despues de borrar es 2: ", abb_contar_hojas(arbol0) == 2);
//~
print_test("Guardo clave 30, ballena franca en arbol0: ", abb_guardar(arbol0, "30", val6));
print_test("Guardo clave -1, colibri en arbol0: ", abb_guardar(arbol0, "-1", val7));
print_test("Guardo clave -6, perro callejero en arbol0: ", abb_guardar(arbol0, "-6", val8));
print_test("Guardo clave 15, marsupial en arbol0: ", abb_guardar(arbol0, "15", val9));
print_test("Cantidad de hojas arbol0 es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Borro nodo con un solo hijo, clave -1, devuelve el dato colibri: ", abb_borrar(arbol0, "-1") == val7);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "-1"));
print_test("Cantidad de arbol0 despues de borrar es 6: ", abb_cantidad(arbol0) == 6);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Borro nodo con un solo hijo, clave 30, devuelve el dato ballena franca: ", abb_borrar(arbol0, "30") == val6);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "30"));
print_test("Cantidad de arbol0 despues de borrar es 5: ", abb_cantidad(arbol0) == 5);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Guardo clave -7, mariposa en arbol0: ", abb_guardar(arbol0, "-7", val10));
print_test("Guardo clave 0, pavo real en arbol0: ", abb_guardar(arbol0, "0", val11));
print_test("Cantidad de hojas arbol0 es 4: ", abb_contar_hojas(arbol0) == 4);
print_test("Borro nodo con un dos hijos, clave 2, devuelve el dato oso hormiguero: ", abb_borrar(arbol0, "2") == val5);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "2"));
print_test("Cantidad de arbol0 despues de borrar es 6: ", abb_cantidad(arbol0) == 6);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 3);
print_test("Borro nodo raiz con un dos hijos, clave 52, devuelve el dato pez espada: ", abb_borrar(arbol0, "52") == val1);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol0, "52"));
print_test("Cantidad de arbol0 despues de borrar es 5: ", abb_cantidad(arbol0) == 5);
print_test("Cantidad de hojas arbol0 despues de borrar es 3: ", abb_contar_hojas(arbol0) == 2);
//~
abb_t* arbol3 = abb_crear(cmp, NULL);
print_test("Guardo clave -7, mariposa en arbol3: ", abb_guardar(arbol3, "-7", val10));
print_test("Busco clave -7 con abb_obtener, devuelve mariposa: ", val10 == abb_obtener(arbol3, "-7"));
print_test("Borro nodo raiz sin hijos, clave -7, devuelve el dato mariposa: ", abb_borrar(arbol3, "-7") == val10);
abb_destruir(arbol3);
// Iterador externo
printf("Iterador inorder con función de impresión: \n");
abb_in_order(arbol0, printear_dato_est, NULL);
// Iterador interno
// Con arbol no vacio
abb_iter_t* iter = abb_iter_in_crear(arbol0);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter));
const char* clave = abb_iter_in_ver_actual(iter);
int clave_int = atoi(clave);
print_test("Iterador interno (-7): ", clave_int == -7);
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (-6)): ", clave_int == -6);
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (0)): ", clave_int == 0);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter));
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (15)): ", clave_int == 15);
abb_iter_in_avanzar(iter);
clave = abb_iter_in_ver_actual(iter);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (99)): ", clave_int == 99);
abb_iter_in_avanzar(iter);
print_test("Iterador interno (avanzar, al final): ", !abb_iter_in_ver_actual(iter));
print_test("Iterador interno (al final es true): ", abb_iter_in_al_final(iter));
abb_iter_in_destruir(iter);
// Con arbol vacio
abb_t* arbol1 = abb_crear(cmp, NULL);
abb_iter_t* iter1 = abb_iter_in_crear(arbol1);
print_test("Iterador interno, arbol vacio (ver actual es NULL): ", !abb_iter_in_ver_actual(iter1));
print_test("Iterador interno, arbol vacio (al final es true): ", abb_iter_in_al_final(iter1));
print_test("Iterador interno, arbol vacio (avanzar es false): ", !abb_iter_in_avanzar(iter1));
abb_iter_in_destruir(iter1);
// Destruir arbol
abb_destruir(arbol0);
abb_destruir(arbol1);
/*Arbol con datos dinamicos tipo listas*/
// Creo un arbol vacio
abb_t* arbol2 = abb_crear(*cmp, *destruir_dato_lista);
print_test("Prueba arbol2 vacio: ", arbol2);
print_test("Cantidad de arbol2 es 0: ", abb_cantidad(arbol2) == 0);
// Guardo clave 5, val12 en la raiz de arbol2
print_test("Guardo clave 52, val12 en la raiz de arbol2: ", abb_guardar(arbol2, "52", val12));
print_test("Cantidad de arbol2 es 1: ", abb_cantidad(arbol2) == 1);
// Guardo clave 2, val13 en arbol2. Debe guardarse en el hijo izquierdo de 5.
print_test("Guardo clave 2, val13 en arbol2: ", abb_guardar(arbol2, "2", val13));
print_test("Cantidad de arbol2 es 2: ", abb_cantidad(arbol2) == 2);
// Guardo clave 33, val14 en arbol2. Debe guardarse en el hijo derecho de 2.
print_test("Guardo clave 33, val14 en arbol2: ", abb_guardar(arbol2, "33", val14));
print_test("Cantidad de arbol2 es 3: ", abb_cantidad(arbol2) == 3);
// Guardo clave 99, val15 en arbol2. Debe guardarse en el hijo derecho de 5.
print_test("Guardo clave 99, val15 en arbol2: ", abb_guardar(arbol2, "99", val15));
print_test("Cantidad de arbol2 es 4: ", abb_cantidad(arbol2) == 4);
// Guardo clave 2, val16 en arbol2. Debe reemplazar a (2, val13).
print_test("Reemplazo dato de clave 2 por val16 en arbol2: ", abb_guardar(arbol2, "2", val16));
// La cantidad debe haber permanecido constante.
print_test("Cantidad de arbol2 es 4: ", abb_cantidad(arbol2) == 4);
// Busco clave 2
print_test("Busco clave 2 con abb_obtener, devuelve val16: ", val16 == abb_obtener(arbol2, "2"));
// Busco clave 111, no existe
print_test("Busco clave 111 con abb_obtener, devuelve NULL: ", NULL == abb_obtener(arbol2, "111"));
// Busco clave 33
print_test("Busco clave 33 con abb_pertenece, devuelve true: ", abb_pertenece(arbol2, "33"));
// Busco clave 10, no pertenece
print_test("Busco clave 10 con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "10"));
// Borrar
print_test("Cantidad de arbol2 antes de borrar es 4: ", abb_cantidad(arbol2) == 4);
print_test("Borro nodo hoja, clave 33, devuelve el dato val14: ", abb_borrar(arbol2, "33") == val14);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "33"));
print_test("Cantidad de arbol2 despues de borrar es 3: ", abb_cantidad(arbol2) == 3);
print_test("Cantidad de hojas arbol2 despues de borrar es 2: ", abb_contar_hojas(arbol2) == 2);
print_test("Guardo clave 30, val17 en arbol2: ", abb_guardar(arbol2, "30", val17));
print_test("Guardo clave -1, val18 en arbol2: ", abb_guardar(arbol2, "-1", val18));
print_test("Guardo clave -6, val19 en arbol2: ", abb_guardar(arbol2, "-6", val19));
print_test("Guardo clave 15, val20 en arbol2: ", abb_guardar(arbol2, "15", val20));
print_test("Cantidad de hojas arbol2 es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Borro nodo con un solo hijo, clave -1, devuelve el dato val18: ", abb_borrar(arbol2, "-1") == val18);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "-1"));
print_test("Cantidad de arbol2 despues de borrar es 6: ", abb_cantidad(arbol2) == 6);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Borro nodo con un solo hijo, clave 30, devuelve el dato val17: ", abb_borrar(arbol2, "30") == val17);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "30"));
print_test("Cantidad de arbol2 despues de borrar es 5: ", abb_cantidad(arbol2) == 5);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Guardo clave -7, val21 en arbol2: ", abb_guardar(arbol2, "-7", val21));
print_test("Guardo clave 0, val22 en arbol2: ", abb_guardar(arbol2, "0", val22));
print_test("Cantidad de hojas arbol2 es 4: ", abb_contar_hojas(arbol2) == 4);
print_test("Borro nodo con un dos hijos, clave 2, devuelve el dato val16: ", abb_borrar(arbol2, "2") == val16);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "2"));
print_test("Cantidad de arbol2 despues de borrar es 6: ", abb_cantidad(arbol2) == 6);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 3);
print_test("Borro nodo raiz con un dos hijos, clave 52, devuelve el dato val12: ", abb_borrar(arbol2, "52") == val12);
print_test("Busco el nodo borrado con abb_pertenece, devuelve false: ", !abb_pertenece(arbol2, "52"));
print_test("Cantidad de arbol2 despues de borrar es 5: ", abb_cantidad(arbol2) == 5);
print_test("Cantidad de hojas arbol2 despues de borrar es 3: ", abb_contar_hojas(arbol2) == 2);
// Iterador externo
printf("Iterador inorder con funcion de impresion:\n");
abb_in_order(arbol2, printear, NULL);
// Iterador interno
abb_iter_t* iter_Auto = abb_iter_in_crear(arbol2);
int contador = 0;
while (!abb_iter_in_al_final(iter_Auto)){
abb_iter_in_avanzar(iter_Auto);
contador++;
}
print_test("Iterador interno recorre todos los elementos: ", abb_cantidad(arbol2) == contador);
abb_iter_in_destruir(iter_Auto);
abb_iter_t* iter2 = abb_iter_in_crear(arbol2);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter2));
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (-7): ", clave_int == -7);
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (-6)): ", clave_int == -6);
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (0)): ", clave_int == 0);
print_test("Iterador interno (al final es false): ", !abb_iter_in_al_final(iter2));
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (15)): ", clave_int == 15);
abb_iter_in_avanzar(iter2);
clave = abb_iter_in_ver_actual(iter2);
clave_int = atoi(clave);
print_test("Iterador interno (avanzar (99)): ", clave_int == 99);
abb_iter_in_avanzar(iter2);
print_test("Iterador interno (avanzar, al final): ", !abb_iter_in_ver_actual(iter2));
print_test("Iterador interno (al final es true): ", abb_iter_in_al_final(iter2));
abb_iter_in_destruir(iter2);
// Destruir arbol
abb_destruir(arbol2); // Destruyo val20, val21, val15, val19, val22. Ya destrui val13
// Destruyo las listas que quedaron
//~ lista_destruir(val12, NULL);
//~ //lista_destruir(val13, NULL);
//~ lista_destruir(val14, NULL);
//~ lista_destruir(val16, NULL);
//~ lista_destruir(val17, NULL);
//~ lista_destruir(val18, NULL);
//~
// Nuevas pruebas
cola_t* val23 = cola_crear();
cola_t* val24 = cola_crear();
char* clave2 = "2";
char* clave3 = "3";
cola_encolar(val23, "a");
cola_encolar(val24, "d");
abb_t* arbol4 = abb_crear(*cmp, destruir_cola);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Guardo clave 2 en la raiz de arbol4: ", abb_guardar(arbol4, clave2, val23));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 2 es val23: ", abb_obtener(arbol4, clave2) == val23);
print_test("Borro clave 2: ", abb_borrar(arbol4, clave2) == val23);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Prueba abb_obtener clave 2 es falso: ", !abb_obtener(arbol4, clave2));
print_test("Guardo clave 2 en la raiz de arbol4: ", abb_guardar(arbol4, clave2, val24));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 2 es val24: ", abb_obtener(arbol4, clave2) == val24);
print_test("Reemplazo el valor de clave 2, en arbol4: ", abb_guardar(arbol4, clave2, val23));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 2 es val23: ", abb_obtener(arbol4, clave2) == val23);
print_test("Borro clave 2: ", abb_borrar(arbol4, clave2) == val23);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Prueba abb_obtener clave 2 es falso: ", !abb_obtener(arbol4, clave2));
print_test("Guardo clave 3, en arbol4: ", abb_guardar(arbol4, clave3, val23));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 3 es val23: ", abb_obtener(arbol4, clave3) == val23);
print_test("Reemplazo clave 3, en arbol4: ", abb_guardar(arbol4, clave3, val24));
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 3 es val24: ", abb_obtener(arbol4, clave3) == val24);
print_test("Guardo clave 2 en la raiz de arbol4: ", abb_guardar(arbol4, clave2, val24));
print_test("Cantidad de arbol4 es 2: ", abb_cantidad(arbol4) == 2);
print_test("Prueba abb_obtener clave 2 es val24: ", abb_obtener(arbol4, clave2) == val24);
print_test("Borro clave 3: ", abb_borrar(arbol4, clave3) == val24);
print_test("Cantidad de arbol4 es 1: ", abb_cantidad(arbol4) == 1);
print_test("Prueba abb_obtener clave 3 es falso: ", !abb_obtener(arbol4, clave3));
//Modifico desde afuera clave2 (valor original "2"):
clave2 = "33";
// Sin embargo en el arbol sigue estando "2"
print_test("Prueba abb_obtener clave 2 es val24: ", abb_obtener(arbol4, "2") == val24);
print_test("Borro clave 2: ", abb_borrar(arbol4, "2") == val24);
print_test("Cantidad de arbol4 es 0: ", abb_cantidad(arbol4) == 0);
print_test("Prueba abb_obtener clave 2 es falso: ", !abb_obtener(arbol4, "2"));
abb_iter_t* iter4 = abb_iter_in_crear(arbol4);
abb_iter_in_destruir(iter4);
abb_iter_t* iter5 = abb_iter_in_crear(arbol4);
print_test("Iterador interno (actual NULL): ", !abb_iter_in_ver_actual(iter5));
print_test("Iterador interno (avanzar falso): ", !abb_iter_in_avanzar(iter5));
abb_iter_in_destruir(iter5);
//~ cola_destruir(val23, NULL);
//~ cola_destruir(val24, NULL);
//~
abb_destruir(arbol4);
}