// Inserta en una lista en la posicion actual del iterador
// Pre: el iterador y la lista fueron creados
// Post: devuelve NULL si algun parametro no es correcto
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato)
{
if(!lista || !iter || !dato)
return false;
// Caso 1: Iter al principio de la lista
if(!iter->nodo_ant)
{
if(!lista_insertar_primero(lista, dato))
return false;
iter->nodo_act = lista->primero;
iter->nodo_ant = NULL;
return true;
}
nodo_t* nodo = malloc(sizeof(nodo_t));
if(nodo == NULL) return false;
nodo->dato = dato;
// Caso 2: Iter al final
if(lista_iter_al_final(iter))
{
nodo->siguiente = NULL;
lista->ultimo = nodo;
}
else // Caso 3: Iter entre dos nodos
nodo->siguiente = iter->nodo_act;
iter->nodo_ant->siguiente = nodo;
iter->nodo_act = nodo;
lista->largo++;
return true;
}
bool lista_insertar_ultimo(lista_t *lista, void *dato){
if (lista_esta_vacia(lista)){
return lista_insertar_primero(lista, dato);
}
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
lista->ultimo->siguiente = nodo;
lista->ultimo = nodo;
lista->largo++ ;
return true;
}
// Agrega un nuevo elemento al final de la lista. Devuelve falso en caso de error.
// Pre: la lista fue creada.
// Post: se agregó un nuevo elemento a la lista, valor se encuentra al final
// de la lista.
bool lista_insertar_ultimo(lista_t *lista, void* valor)
{
if(!lista) return false;
if(lista_esta_vacia(lista))
return lista_insertar_primero(lista, valor);
nodo_t* nodo = malloc(sizeof(nodo_t));
nodo->dato = valor;
nodo->siguiente = NULL;
if(nodo == NULL)
return false;
lista->ultimo->siguiente = nodo;
lista->ultimo = nodo;
lista->largo++;
return true;
}
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato){
if (iter->anterior == NULL && iter->actual != NULL){ // o sea si iter = posicion inicial
//Estoy en el primer nodo
lista_insertar_primero(lista, dato);
//Actualizo el iterador
iter->actual = lista->inicio;
iter->anterior = NULL;
lista->largo +=1;
return true;
}
//if
nodo_t* nodo_nuevo = nodo_crear(dato);
if (nodo_nuevo == NULL) return false;
(iter->anterior)->ref = nodo_nuevo;
nodo_nuevo->ref = iter->actual;
lista->largo +=1;
//Actualizo el iterador
iter->actual = nodo_nuevo;
return true;
}
bool lista_iter_insertar(lista_iter_t *iter, void *dato){
bool res;
if (iter->actual == iter->lista->primero){
res = lista_insertar_primero(iter->lista, dato);
iter->actual = iter->lista->primero ;
return res;
}
if(lista_iter_al_final(iter)){
res = lista_insertar_ultimo(iter->lista, dato);
iter->actual = iter->lista->ultimo;
return res;
}
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
nodo->siguiente = iter->actual;
iter->actual = nodo;
iter->anterior->siguiente = nodo;
iter->lista->largo++ ;
return true;
}
bool almacenar(hash_t* hash, lista_t** tabla, daton_t* paquete, unsigned long largo){
bool resu;
unsigned long indice = fh(paquete->clave, largo );
if (!tabla[indice]){
tabla[indice] = lista_crear();
}
lista_iter_t* iter_l = busqueda(tabla[indice], paquete->clave);
if (lista_iter_al_final(iter_l)) { //no lo encontro
resu = lista_insertar_primero(tabla[indice], paquete);
hash->tam++;
lista_iter_destruir(iter_l);
return resu;
}
daton_t* aux = lista_iter_borrar(iter_l);
free(aux->clave);
if (hash->destruir_dato) hash->destruir_dato(aux->dato);
free(aux);
resu = lista_insertar_ultimo(tabla[indice], paquete);
lista_iter_destruir(iter_l);
return resu;
}
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato) {
// Si estoy en la primera posición del iterador
if (!iter->anterior) {
if (lista_insertar_primero(lista, dato)) iter->actual = lista->inicio;
else return false;
}
// Si estoy en la última posición del iterador
else if (lista_iter_al_final(iter)) {
if (lista_insertar_ultimo(lista, dato)) iter->actual = lista->fin;
else return false;
}
// Si estoy en cualquier otra posición del iterador
else {
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
iter->anterior->siguiente = nodo;
nodo->siguiente = iter->actual;
iter->actual = nodo;
lista->largo++;
}
return true;
}
// Inserta un nuevo elemento a la lista en la posicion del iterador,
// devuelve falso en caso de error.
// Pre: la lista y el iterador fueron creados.
// Post: se insertó un nuevo elemento en la lista.
bool lista_insertar(lista_t *lista, lista_iter_t *iter, void *dato)
{
/* Creamos una variable para verificar que, en caso de ser usadas,
* insertar_primero o insertar_ultimo funcionaron correctamente */
bool exito = true;
/* Si el iterador está al principio de la lista o la lista
* está vacía, insertamos en el primero */
if (!iter->anterior && (exito = lista_insertar_primero(lista, dato))){
iter->actual = lista->primero;
return true;
}
/* Si el iterador está al final de la lista insertamos en el ultimo */
if (lista_iter_al_final(iter) && (exito = lista_insertar_ultimo(lista, dato))){
iter->actual = lista->ultimo;
return true;
}
/* El iterador no está al final ni al principio de la lista */
if (exito){
/* Creamos el nuevo nodo con el dato a insertar */
nodo_t* nodo_nuevo = crear_nodo(dato);
if (!nodo_nuevo)
return false;
/* Ubicamos el nuevo nodo en la posicion en donde se
* encontraba el iterador, iter->actual pasa a ser el nuevo
* nodo insertado e iter->anterior se mantiene constante */
nodo_nuevo->prox = iter->actual;
iter->actual = nodo_nuevo;
iter->anterior->prox = nodo_nuevo;
lista->cantidad++;
return true;
}
/* lista_insertar_primero o lista_insertar_ultimo devolvió false */
return false;
}
hash_t* hash_redimensionar(hash_t* hash, size_t tamanio) {
lista_t** nueva_tabla = creacion_tabla(hash,tamanio);
if (nueva_tabla == NULL) return NULL;
for (int i = 0; i < hash->tamanio; i ++) {
lista_iter_t* iter = lista_iter_crear(hash->tabla[i]);
const char* clave;
size_t posicion;
nodo_hash_t* nodo;
while (!lista_iter_al_final(iter)) {
nodo = lista_borrar(hash->tabla[i],iter);
clave = nodo->clave;
posicion = fhash(clave,tamanio);
lista_insertar_primero(nueva_tabla[posicion],nodo);
}
lista_destruir(hash->tabla[i],NULL);
lista_iter_destruir(iter);
}
free(hash->tabla);
hash->tamanio = tamanio;
hash->tabla = nueva_tabla;
return hash;
}
bool hash_guardar(hash_t* hash, const char* clave, void* dato) {
size_t posicion = fhash(clave,hash->tamanio);
nodo_hash_t* nodo_clave = buscar_clave(hash->tabla[posicion],clave);
// si la clave no existe
if (nodo_clave == NULL) {
nodo_hash_t* nodo = creacion_nodo(clave,dato);
lista_insertar_primero(hash->tabla[posicion],nodo);
hash->cantidad ++;
}
// si la clave ya existe, reemplazo el dato
if (nodo_clave != NULL) {
if (hash->destruir_dato != NULL) {
hash->destruir_dato(nodo_clave->dato);
}
nodo_clave->dato = dato;
}
//Factor de carga de 70 %
float resultado = (hash->cantidad)/(hash->tamanio);
if (resultado > FACTORCARGA)
hash_redimensionar(hash,(hash->tamanio)*2);
return true;
}
/* Pruebas */
void prueba_tipos() {
// Declaro de variables
lista_iter_t *iter;
lista_t* lista;
alumno_t* alumno1;
alumno_t* alumno2;
alumno_t* alumno3;
int padron1=94111;
int padron2=77777;
int padron3=10104;
// las inicializo
lista = lista_crear();
alumno1=alumno_crear(padron1);
alumno2=alumno_crear(padron2);
alumno3=alumno_crear(padron3);
printf("---------------------------PRUEBAS---------------------------\n");
//pruebo que este vacia
print_test("Pruebo que la lista se crea vacía", lista_esta_vacia(lista) );
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//inserto ultimo
print_test("Inserto ultimo elemento alumno2", lista_insertar_ultimo(lista,alumno2) );
//inesrto un nuevo ultimo
print_test("Inserto ultimo elemento alumno3", lista_insertar_ultimo(lista,alumno3) );
//veo el primero
print_test("Veo el primer elemento(alumno1)", alumno1==lista_ver_primero(lista));
//borro el primero y veo devuelta
print_test("Borro el primero", lista_borrar_primero(lista));
print_test("Veo el primer elemento(alumno2)", alumno2==lista_ver_primero(lista));
//veo el largo de la lista
print_test("Veo el largo de la lista (2)", 2==lista_largo(lista));
//creo iterador
iter= lista_iter_crear(lista);
//pruebas del iterador
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo elemento actual del iterador (alumno3)", alumno3==lista_iter_ver_actual(iter));
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo si esta al final", lista_iter_al_final(iter));
//pruebas de lista junto con iterador
print_test("Inserto de nuevo alumno1", lista_insertar(lista,iter,alumno1));
print_test("Lo borro", alumno1==lista_borrar(lista,iter));
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//destruyo el iterador
lista_iter_destruir(iter);
//creo iterador
iter= lista_iter_crear(lista);
print_test("Destruyo iterador,lo creo devuelta y borro el primer elemento (alumno1)", alumno1==lista_borrar(lista,iter));
destruir_dato(alumno1);
//destruyo lista e iterador
lista_iter_destruir(iter);
lista_destruir(lista,destruir_dato);
}
void lista_prueba(){
//Pruebo crear listas
lista_t* lista1 = lista_crear();
lista_t* lista2 = lista_crear();
lista_t* lista3 = lista_crear();
print_test("Probando si lista1 se creo bien", lista1!=NULL);
print_test("Probando si lista1 esta vacia", lista_esta_vacia(lista1));
print_test("Probando si el largo de lista2 es 0", lista_largo(lista2)==0);
int vector[]={ 1, 2, 3, 4};
char vector2[]="hola que tal";
// Probando insertar en la lista;
print_test("Probando si se inserta al principio un elemento en la lista1", lista_insertar_primero(lista1, &vector));
print_test("Probando si se inserta al final un elemento en la lista1", lista_insertar_ultimo(lista1, &vector2));
// Probando el largo de la lista con 2 elementos
print_test("Probando que el largo de la lista1 sea dos", lista_largo(lista1)==2);
// Probando el lista borrar primero en la lista 1
print_test("Probando si se borra el primer elemento en la lista1", lista_borrar_primero(lista1) == vector);
// Probando el lista ver primero
print_test("Probando ver el primero de la lista 1", lista_ver_primero(lista1) == vector2 );
// Probando agregar al principio en lista 3
print_test("Probando si se inserta al principio un elemento en la lista3", lista_insertar_primero(lista3, &vector));
lista_insertar_ultimo(lista3, &vector2);
// PRUEBAS CON EL ITERADOR CON LA LISTA 3
lista_iter_t* iter = lista_iter_crear(lista3);
// Probando el iter avanzar
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
// Probando el iter ver actual
print_test("Probando el iter ver actual", lista_iter_ver_actual(iter) == vector2);
// Probando el iter al final
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
print_test("Probando el iter avanzar (no puede avanzar mas)", lista_iter_avanzar(iter) == false);
print_test("Probando el iter al final", lista_iter_al_final(iter));
print_test("Probando si el iter esta el final el ver_actual", lista_iter_ver_actual(iter) == NULL);
lista_iter_destruir(iter);
// Probando lista_insertar con iterador
lista_iter_t* iter2 = lista_iter_crear(lista2);
char vector3[]="chau";
print_test("Probando el lista_insertar en la lista con el iter", lista_insertar(lista2,iter2,&vector3));
print_test("Probando ver el primero de la lista2", lista_ver_primero(lista2) == &vector3 );
print_test("Probando borrar con el iter", lista_borrar(lista2,iter2) == vector3 );
print_test("Probando el lista_ver_primero con los nodos borrados", lista_ver_primero(lista2) == NULL );
print_test("Probando el largo de una lista vacia", lista_largo(lista2) == 0 );
print_test("Probando el lista_borrar_primero en una lista vacia", lista_borrar_primero(lista2) == NULL );
lista_iter_destruir(iter2);
// Pruebo Agregar 30 Datos y luego borrarlos
for ( int i=0 ; i < 30 ; i++){
lista_insertar_ultimo(lista2, &i);
}
print_test("Probando el largo de la lista2 luego de agregar 30 elementos", lista_largo(lista2) == 30);
lista_iter_t* iter3=lista_iter_crear(lista2);
while (!lista_iter_al_final(iter3)){
lista_borrar(lista2,iter3);
}
print_test("Probando que se borraron todos los elementos" , lista_largo(lista2) == 0);
print_test("Prubando borrar un elemento en una lista vacia" , lista_borrar(lista2,iter3) == NULL);
lista_iter_destruir(iter3);
//Finalmente, pruebo si estan vacias las 3 listas
print_test( "Probando que la lista1 no este vacia", lista_esta_vacia(lista1) == false );
print_test( "Probando que la lista2 este vacia", lista_esta_vacia(lista2) );
print_test( "Probando que la lista3 no este vacia", lista_esta_vacia(lista3) == false );
//Elimino las 3 listas
lista_destruir(lista1, NULL);
lista_destruir(lista2, NULL);
lista_destruir(lista3, NULL);
/* ******************************************************************
* Pruebas con lista 4
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista4 = lista_crear();
for( int num=1; num <= 10 ; num++){
int elemento=1;
lista_insertar_ultimo(lista4 , &elemento);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 10 );
lista_iter_t* iter4= lista_iter_crear(lista4);
print_test("Probando que se creo el iter 4", iter4!=NULL);
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
for (int j=1; j<=10; j++){
lista_iter_avanzar(iter4);
}
print_test("Probando que el iter 4 este al final", lista_iter_al_final(iter4));
char prueba[] = "prueba";
print_test("Probando lista_insertar con el iter al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
print_test("Probando avanzar con el iter 4 al final", lista_iter_avanzar(iter4));
print_test("Probando lista_borrar con el iter 4 al final", lista_borrar(lista4,iter4) == NULL);
print_test("Probando lista_insertar con el iter 4 al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando lista_borrar con el iter 4", lista_borrar(lista4,iter4) == prueba);
for (int j=0; j<=10; j++){
lista_borrar_primero(lista4);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 0 );
// elimino el iter 4
lista_iter_destruir(iter4);
//Elimino la lista
lista_destruir(lista4, free);
/* ******************************************************************
* Pruebas con lista 5
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista5 = lista_crear();
// le creo un iter
lista_iter_t* iter5= lista_iter_crear(lista5);
print_test("Probando que se creo el iter 5", iter5!=NULL);
for( int num=1; num <= 10 ; num++){
char elemento2[]="hola";
lista_insertar(lista5, iter5, &elemento2);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 10 );
print_test("Probando que el iter 5 no este al final", lista_iter_al_final(iter5) == false);
char prueba2[] = "prueba";
print_test("Probando lista_borrar con el iter 5 al principio", lista_borrar(lista5,iter5) != NULL);
print_test("Probando lista_insertar con el iter 5 al principio", lista_insertar(lista5, iter5, &prueba2));
print_test("Probando lista_borrar con el iter 5 ", lista_borrar(lista5,iter5) == prueba2);
for (int j=0; j<=10; j++){
lista_borrar(lista5, iter5);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 0 );
print_test("Probando que la lista 5 este vacia", lista_esta_vacia(lista5));
print_test("Probando lista ver_primero de la lista 5", lista_ver_primero(lista5) == NULL);
print_test("Probando avanzar con el iter 5 al final", lista_iter_avanzar(iter5) == false);
print_test("Probando avanzar con el iter 5 al final", lista_iter_ver_actual(iter5) == NULL);
// elimino el iter 5
lista_iter_destruir(iter5);
//Elimino la lista
lista_destruir(lista5, free);
/* ******************************************************************
* Pruebas con lista 6
* *****************************************************************/
// Creo una nueva Lista
lista_t* lista6 = lista_crear();
// le creo un iter
lista_iter_t* iter6= lista_iter_crear(lista6);
print_test("Probando que se creo el iter 6", iter6!=NULL);
void* elemento = malloc(sizeof(void*)) ;
print_test("Probando agregar un elemento con lista_insertar con la lista 6 vacia", lista_insertar(lista6, iter6, elemento));
print_test("Probando largo de la lista 6", lista_largo(lista6) == 1 );
print_test("Probando que el iter 6 no este al final", lista_iter_al_final(iter6) == false);
print_test("Probando si puedo avanzar con el iter 6", lista_iter_avanzar(iter6));
print_test("Probando que el iter 6 este al final", lista_iter_al_final(iter6));
void* borrar=lista_borrar_primero(lista6);
free(borrar);
// elimino el iter 6
lista_iter_destruir(iter6);
//Elimino la lista 6
lista_destruir(lista6, free);
/* ******************************************************************
* Pruebas con lista 7
* *****************************************************************/
lista_t* lista7 = lista_crear();
for (int x=1 ; x<=10 ; x++){
lista_insertar_primero(lista7, &x);
}
lista_iter_t* iter7 = lista_iter_crear(lista7);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
while (!lista_iter_al_final(iter7)){
lista_iter_avanzar(iter7);
}
void* y;
print_test("Probando si se puede ver el elemento actual del iter", lista_iter_ver_actual(iter7) == NULL);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el largo de la lista7 sea 11", lista_largo(lista7) == 11);
print_test("Probando borrar el ultimo elemento de lista7", lista_borrar(lista7,iter7) == &y);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el iter7 no quede al final", lista_iter_al_final(iter7) == false);
lista_iter_destruir(iter7);
lista_destruir(lista7, NULL);
/* ******************************************************************
* Pruebas con lista 8
* *****************************************************************/
lista_t* lista8 = lista_crear();
for (int x=1 ; x<=5 ; x++){
lista_insertar_ultimo(lista8, &x);
}
print_test("Probando que el largo de la lista8 sea 5", lista_largo(lista8) == 5);
lista_iter_t* iter8 = lista_iter_crear(lista8);
int elem=0;
print_test("Probando que el elemento actual del iter8 no es null", lista_iter_ver_actual(iter8) != NULL);
print_test("Probando insertar al principio con el iter en lista8", lista_insertar(lista8, iter8, &elem));
print_test("Probando que el largo de lista8 sea 6", lista_largo(lista8) == 6);
print_test("Probando eliminar el primer elemento de la lista8 con el iter", lista_borrar(lista8, iter8) == &elem);
print_test("Probado que el largo de la lista8 es 5", lista_largo(lista8) == 5);
print_test("Probando insertar un elemento en la primera posicion de lista8", lista_insertar_primero(lista8, &elem));
print_test("Probando que el actual del iter8 sea distinto que el primero de lista8", lista_ver_primero(lista8) != lista_iter_ver_actual(iter8));
lista_iter_destruir(iter8);
lista_destruir(lista8 , NULL);
/* ******************************************************************
* Pruebas con lista 9
* *****************************************************************/
lista_t* lista9 = lista_crear();
int num;
print_test("Probando insertar el elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando que el largo de lista9 es 1", lista_largo(lista9));
lista_iter_t* iter9 = lista_iter_crear(lista9);
print_test("Probando que el elemento actual del iter9 no es null", lista_iter_ver_actual(iter9) != NULL);
print_test("Probando borrar el elemento de lista9 con el iter", lista_borrar(lista9, iter9) == &num);
print_test("Probando que el largo de lista9 es 0", lista_largo(lista9) == 0);
print_test("Probando borrar un elemento de la lista9 que esta vacia", lista_borrar(lista9, iter9) == NULL);
print_test("Probando avanzar en lista9 que esta vacia", lista_iter_avanzar(iter9) == false);
print_test("Probando agregar un elemento con el iter9", lista_insertar(lista9, iter9, &num));
print_test("Probando eliminar el ultimo elemento con el iter9", lista_borrar(lista9, iter9) == &num);
print_test("Probando agregar un elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando eliminar el ultimo elemento con borrar primero", lista_borrar_primero(lista9) == &num);
lista_iter_destruir(iter9);
lista_destruir(lista9 , NULL);
lista_t* lista10= lista_crear();
int i=0;
print_test("Probando agregar un elemento a lista10", lista_insertar_primero(lista10 , &i));
print_test("Probando eliminar primer elemento", lista_borrar_primero(lista10) != NULL);
lista_destruir(lista10, NULL);
}
