Example #1
0
// 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);
}
Example #2
0
File: abb.c Project: fonse451/abb
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;
}
Example #3
0
File: abb.c Project: fonse451/abb
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;
}
Example #4
0
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);
	
	
}
Example #5
0
/* 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);


}