void* hash_borrar(hash_t* hash, const char* clave) { if (!hash_pertenece(hash,clave)) return NULL; size_t posicion = fhash(clave,hash->tamanio); lista_iter_t* iter = lista_iter_crear(hash->tabla[posicion]); nodo_hash_t* nodo = lista_iter_ver_actual(iter); bool esta = false; while (!lista_iter_al_final(iter)) { if (strcmp(nodo->clave,clave) == 0) { esta = true; break; } lista_iter_avanzar(iter); nodo = lista_iter_ver_actual(iter); } if (esta == false) { lista_iter_destruir(iter); return NULL; } nodo = (nodo_hash_t*)lista_borrar(hash->tabla[posicion],iter); void* dato = nodo->dato; free(nodo->clave); free(nodo); lista_iter_destruir(iter); hash->cantidad --; return dato; }
lista_iter_t* busqueda(lista_t* lista, const char* clave){ lista_iter_t* iter = lista_iter_crear(lista); daton_t* aux= lista_iter_ver_actual(iter); while (!lista_iter_al_final(iter) && strcmp(aux->clave, clave) != 0) { lista_iter_avanzar(iter); aux= lista_iter_ver_actual(iter); } return iter; }
/* Procesar todos los votos y volcar resultados */ bool comando_cerrar(maquina_votacion_t* maquina, char* entrada[]) { #ifdef DEBUG printf("Comando cerrar ejecutado\n"); #endif if(maquina->estado < ABIERTA) return error_manager(OTRO); if(maquina->estado > ABIERTA || !cola_esta_vacia(maquina->cola) ) return error_manager(COLA_NO_VACIA); lista_iter_t* iter = lista_iter_crear(maquina->listas); if(!iter) return error_manager(OTRO); while(!lista_iter_al_final(iter)) { partido_politico_t* partido = lista_iter_ver_actual(iter); if(!partido) { lista_iter_destruir(iter); return error_manager(OTRO); } printf("%s:\n", partido_nombre(partido)); for(size_t i=0;i<partido_largo(partido);i++) { size_t* votos = partido_votos(partido)[i]; printf("%s: %zu votos\n", CARGOS[i], *votos); } // Liberar memoria destruir_partido(partido); lista_iter_avanzar(iter); } lista_iter_destruir(iter); lista_destruir(maquina->listas, NULL); maquina->listas = NULL; return false; }
int listar_fabricas(base_t* base,bool imprimir){ int hora,minutos; fabrica_t* fabrica; fabrica_t* anterior; if (lista_esta_vacia(base->fabricasavisitar)){ //creo una lista con las fabricas que voy a visitar anterior = heap_desencolar(base->cerradofabricas); lista_insertar_ultimo(base->fabricasavisitar,(void*)anterior); while (!heap_esta_vacio(base->cerradofabricas)){ fabrica = heap_desencolar(base->cerradofabricas); if (fabrica->horarioentrada>=anterior->horariosalida){ lista_insertar_ultimo(base->fabricasavisitar,(void*)fabrica); anterior = fabrica; } } } if (imprimir){ printf("Cantidad: %zu\n",lista_largo(base->fabricasavisitar)); lista_iter_t* iterador = lista_iter_crear(base->fabricasavisitar); while(!lista_iter_al_final(iterador)){ fabrica = lista_iter_ver_actual(iterador); conversion_horario(&hora,&minutos,fabrica->horarioentrada); printf("%s,%02d:%02d,",fabrica->idfabrica,hora,minutos); conversion_horario(&hora,&minutos,fabrica->horariosalida); printf("%02d:%02d\n",hora,minutos); lista_iter_avanzar(iterador); } lista_iter_destruir(iterador); } return 0; }
bool redimensionar(hash_t* hash, unsigned long nuevo_largo){ lista_t** nueva_tabla = malloc(sizeof(lista_t*) * nuevo_largo); for (int i = 0; i < nuevo_largo; i++){ nueva_tabla[i] = NULL; } lista_iter_t* iter_lista = NULL; daton_t* paquete; hash->tam = 0; for (int a = 0; a < hash->largo ; a++){ if (hash->tabla[a]){ iter_lista = lista_iter_crear(hash->tabla[a]); while (!lista_iter_al_final(iter_lista)){ paquete = lista_iter_ver_actual(iter_lista); almacenar(hash, nueva_tabla, paquete, nuevo_largo); lista_iter_avanzar(iter_lista); } lista_iter_destruir(iter_lista); lista_destruir(hash->tabla[a], NULL); } } hash->largo = nuevo_largo; free(hash->tabla) ; hash->tabla = nueva_tabla; return true; }
const char* hash_iter_ver_actual(const hash_iter_t* iter) { if (hash_iter_al_final(iter)) return NULL; nodo_hash_t* nodo = lista_iter_ver_actual(iter->iter); if (nodo != NULL) return (nodo->clave); return NULL; }
bool preparar_pedidos(vector_t * vectorzonas, vector_t * vectorprecios){ int i, lvacias=0; pedido_t *pedido; lista_iter_t *iter; lista_t* listaaux; int cantidad=vector_obtener_cantidad(vectorzonas); for (i=0; i<cantidad; i++){ listaaux= (lista_t*) vector_obtener(vectorzonas, i); if(lista_esta_vacia(listaaux)==true){ lvacias++; printf("No hay pedidos en la zona %d\n", i+1); } } if (lvacias==cantidad) return false; for (i=0; i<cantidad; i++){ listaaux= (lista_t*) vector_obtener(vectorzonas, i); iter=lista_iter_crear(listaaux); while (lista_iter_al_final(iter)==false){ pedido=(pedido_t *)(lista_iter_ver_actual(iter)); pedido->preparado=true; lista_iter_avanzar(iter); } lista_iter_destruir(iter); } return true; }
curso_t* conseguir_curso(char* idc, lista_t* lista){ int i; int posicion = existe_curso(idc,lista); lista_iter_t* iterador = lista_iter_crear(lista); for(i=0;i<posicion;i++) lista_iter_avanzar(iterador); curso_t* curso = NULL; curso = lista_iter_ver_actual(iterador); lista_iter_destruir(iterador); return curso; }
/* Desencolar y realizar validacion del Documento tipo/numero del votante y no haber votado Crear pila para ciclo de votacion actual */ bool comando_votar_inicio(maquina_votacion_t* maquina) { #ifdef DEBUG printf("Comando votar inicio ejecutado.\n"); #endif // Error handling if(maquina->estado == CERRADA) { return error_manager(MESA_CERRADA); } if(maquina->estado == VOTACION) { return error_manager(OTRO); } if(cola_esta_vacia(maquina->cola)) { return error_manager(NO_VOTANTES); } votante_t* votante_padron = NULL; bool enpadronado = false; votante_t* votante_espera = cola_desencolar(maquina->cola); if(!votante_espera) return error_manager(OTRO); #ifdef DEBUG printf("Votante desencolado: %s, %s\n", votante_espera->documento_tipo, votante_espera->documento_numero); #endif pila_t* ciclo_votacion = pila_crear(); lista_iter_t* lista_iter = lista_iter_crear(maquina->padron); if(!ciclo_votacion || !lista_iter) { if(ciclo_votacion) pila_destruir(ciclo_votacion, NULL); if(lista_iter) free(lista_iter); return error_manager(OTRO); } while(!lista_iter_al_final(lista_iter)) { votante_padron = lista_iter_ver_actual(lista_iter); if(votante_iguales(votante_padron, votante_espera)) { enpadronado = true; break; } lista_iter_avanzar(lista_iter); } lista_iter_destruir(lista_iter); votante_destruir(votante_espera); if(!enpadronado || votante_get_voto_realizado(votante_padron)) { pila_destruir(ciclo_votacion, NULL); return enpadronado ? error_manager(VOTO_REALIZADO) : error_manager(NO_ENPADRONADO); } votante_set_voto_realizado(votante_padron); maquina->estado = VOTACION; maquina->ciclo = ciclo_votacion; maquina->votando_cargo = PRESIDENTE; mostrar_menu_votacion(maquina); return true; }
bool printear(const char* clave, void* lista, void* extra){ printf("Clave: %s\n Datos en lista: ", clave); lista_iter_t* iter_lista = lista_iter_crear(lista); int i =0; while (i <lista_largo(lista)){ printf("%s ", (char*)lista_iter_ver_actual(iter_lista)); i++; } puts("\n"); lista_iter_destruir(iter_lista); return true; }
/* Obtiene el valor de un elemento del hash, si la clave no se encuentra * devuelve NULL. * Pre: La estructura hash fue inicializada */ void *hash_obtener(const hash_t *hash, const char *clave){ unsigned long indice = fh(clave, hash->largo); if (!hash->tabla[indice]) return NULL; lista_iter_t* iter_l = busqueda(hash->tabla[indice], clave); if (lista_iter_al_final(iter_l)) { lista_iter_destruir(iter_l); return NULL; } daton_t* aux = lista_iter_ver_actual(iter_l); void* dato_salida = aux->dato; lista_iter_destruir(iter_l); return dato_salida; }
int alumno_inscripto(char* padron,lista_t* lista){ int i = 0; int estainscripto = -1; char* inscripto; lista_iter_t* iterador = lista_iter_crear(lista); while((!lista_iter_al_final(iterador)) && (estainscripto==-1)){ inscripto = (char*) lista_iter_ver_actual(iterador); if (strcmp(inscripto,padron)==0) estainscripto=i; lista_iter_avanzar(iterador); i++; } lista_iter_destruir(iterador); return estainscripto; }
int existe_curso(char* idc,lista_t* lista){ int vuelta = -1; int i = 0; lista_iter_t* iterador = lista_iter_crear(lista); curso_t* curso; do{ curso = (curso_t*) lista_iter_ver_actual(iterador); if (curso!=NULL){ if (strcmp(idc,curso->idc)==0) vuelta=i; } i++; }while(lista_iter_avanzar(iterador) && (vuelta==-1)); lista_iter_destruir(iterador); return vuelta; }
int valuar_juguetes(base_t* base,char* idfabrica){ if (!hash_pertenece(base->fabricas,idfabrica)) return -1; int sonrisas = 0; int i; //creo la mochila y la inicializo int* mochila = calloc(base->capacidad+1,sizeof(int)); fabrica_t* fabrica = hash_obtener(base->fabricas,idfabrica); //creo el iterador para recorrer los juguetes que tiene la fabrica lista_iter_t* iterador = lista_iter_crear(fabrica->juguetes); juguete_t* juguete = lista_iter_ver_actual(iterador); while(juguete!=NULL){ for(i=base->capacidad;i>0;i--){ if (i-(juguete->peso)>=0){ if (mochila[i]<(mochila[i-juguete->peso]+juguete->valor)) mochila[i]=(mochila[i-juguete->peso]+juguete->valor); } } lista_iter_avanzar(iterador); juguete = lista_iter_ver_actual(iterador); } sonrisas = mochila[base->capacidad]; lista_iter_destruir(iterador); free(mochila); return sonrisas; }
int sesion_inscribir(char* idc,base_t* basedatos, sesion_t* sesion){ //verifico si hay sesion iniciada if (strcmp(sesion->padron,"00000")==0) return -3; //verifico si existe el curso int pos = existe_curso(idc,basedatos->listadecursos); if (pos==-1) return -2; //verifico si ya estaba programada la inscripcion bool yaanotado = false; inscripcion_t* inscripcion; lista_iter_t* iterador = lista_iter_crear(sesion->inscripciones); while(!lista_iter_al_final(iterador) && !yaanotado){ inscripcion = (inscripcion_t*)lista_iter_ver_actual(iterador); if (strcmp(inscripcion->curso,idc)==0) yaanotado=true; lista_iter_avanzar(iterador); } lista_iter_destruir(iterador); if (yaanotado==true) return -4; //consigo el curso int i; iterador = lista_iter_crear(basedatos->listadecursos); for(i=0;i<pos;i++) lista_iter_avanzar(iterador); curso_t* curso = (curso_t*) lista_iter_ver_actual(iterador); lista_iter_destruir(iterador); //verifico si ya esta anotado en el curso if (alumno_inscripto(sesion->padron,curso->inscriptos)!=-1) return -1; //creo la inscripcion inscripcion = malloc(sizeof(inscripcion_t)); if (inscripcion==NULL) return -5; //programo la inscripcion inscripcion->curso = malloc(LIDC*sizeof(char)); strcpy(inscripcion->curso,idc); ((curso->vacantes)>lista_largo(curso->inscriptos)) ? (inscripcion->estado=false) : (inscripcion->estado=true); lista_insertar_ultimo(sesion->inscripciones,inscripcion); if (inscripcion->estado) return 1; return 2; }
bool modificar_pedido(vector_t * vectorzonas, char n[], int cantidad){ int i; if (cantidad<0 || cantidad>5) { printf("La cantidad maxima permitida es de 5 pizzas\n"); return false; } bool encontrado=false; pedido_t *pedido,*pedidoaux; lista_iter_t *iter; lista_t * listaaux; for (i=0;i<vector_obtener_cantidad(vectorzonas);i++){ listaaux= (lista_t*) vector_obtener(vectorzonas, i); iter=lista_iter_crear(listaaux); while ( (!lista_iter_al_final(iter)) && (!encontrado) ){ pedidoaux=(pedido_t*) (lista_iter_ver_actual(iter)); if (pedidoaux){ if (strcmp (pedidoaux->nombre,n)==0){ pedido=(lista_iter_ver_actual(iter)); encontrado=true; } } lista_iter_avanzar(iter); } lista_iter_destruir(iter); } if (encontrado){ pedido->cantidad=cantidad; return true; } return false; }
void listar_cursos(char* filtro,base_t* basedatos){ lista_iter_t* iterador = lista_iter_crear(basedatos->listadecursos); curso_t* curso; int inscriptos; while(!lista_iter_al_final(iterador)){ curso = lista_iter_ver_actual(iterador); inscriptos = lista_largo(curso->inscriptos); if (filtro[0]=='\0'){ fprintf(stdout,"%s: %s (%s) Vacantes: %d Inscriptos: %d\n",curso->idc,curso->descripcion,curso->materia,curso->vacantes,inscriptos); }else{ if (strcmp(filtro,curso->materia)==0) fprintf(stdout,"%s: %s (%s) Vacantes: %d Inscriptos: %d\n",curso->idc,curso->descripcion,curso->materia,curso->vacantes,inscriptos); } lista_iter_avanzar(iterador); } lista_iter_destruir(iterador); }
int valuar_juguetes_total(base_t* base){ int totalsonrisas = 0; int sonrisasfabricas; fabrica_t* fabrica; //if (lista_esta_vacia(base->fabricasavisitar)) return -1; //la lista esta vacia y hay que ver cuales visitar antes if (lista_esta_vacia(base->fabricasavisitar)) listar_fabricas(base,false); //la lista esta vacia y hay que ver cuales visitar antes lista_iter_t* iterador = lista_iter_crear(base->fabricasavisitar); while (!lista_iter_al_final(iterador)){ fabrica = (fabrica_t*)lista_iter_ver_actual(iterador); sonrisasfabricas = valuar_juguetes(base,fabrica->idfabrica); totalsonrisas = (totalsonrisas + sonrisasfabricas); lista_iter_avanzar(iterador); } lista_iter_destruir(iterador); return totalsonrisas; }
// Itera la lista aplicandole la funcion visitar a cada dato almacenado, pasandole el parametro extra para que esta lo utilice // Pre: la lista fue creada void lista_iterar(lista_t *lista, bool (*visitar)(void *dato, void *extra), void *extra) { if(!lista || !visitar || !extra) return; lista_iter_t *iter = lista_iter_crear(lista); if(!iter) return; while( !lista_iter_al_final(iter) && visitar(lista_iter_ver_actual(iter), extra) ) lista_iter_avanzar(iter); lista_iter_destruir(iter); }
bool cancelar_pedido(vector_t * vectorzonas, char n[], int cantidad, int zona){ pedido_t *auxpedido; lista_t* listaaux= (lista_t*) vector_obtener(vectorzonas, (zona-1)); lista_iter_t *iter=lista_iter_crear(listaaux); while (lista_iter_al_final(iter)==false){ auxpedido=(pedido_t*)(lista_iter_ver_actual(iter)); if ( ( (strcmp (auxpedido->nombre,n)==0)) && auxpedido->cantidad==cantidad){ printf("Se borro el pedido, %s",auxpedido->nombre); lista_borrar(listaaux, iter); return true; } lista_iter_avanzar(iter); } return false; }
void sesion_ver(sesion_t* sesion){ if (strcmp(sesion->padron,"00000")==0){ fprintf(stdout,"Error: no hay una sesion en curso\n"); return; } fprintf(stdout,"Padron: %s\n",sesion->padron); if (lista_largo(sesion->inscripciones)==0){ fprintf(stdout,"No hay inscripciones\n"); return; } lista_iter_t* iterador = lista_iter_crear(sesion->inscripciones); inscripcion_t* inscripcion; while(!lista_iter_al_final(iterador)){ inscripcion = (inscripcion_t*)lista_iter_ver_actual(iterador); fprintf(stdout,"%s ",inscripcion->curso); (inscripcion->estado) ? fprintf(stdout,"(condicional)\n") : fprintf(stdout,"(regular)\n"); lista_iter_avanzar(iterador); } lista_iter_destruir(iterador); }
// Funcion auxiliar que busca la clave en la lista y devuelve el nodo nodo_hash_t* buscar_clave(lista_t* lista, const char* clave) { lista_iter_t* iter = lista_iter_crear(lista); bool esta = false; nodo_hash_t* nodo; do { nodo = (nodo_hash_t*)lista_iter_ver_actual(iter); if (nodo != NULL) { if (strcmp(clave,nodo->clave) == 0) { esta = true; } } } while(lista_iter_avanzar(iter) && !esta); if (esta == false) { lista_iter_destruir(iter); return NULL; } lista_iter_destruir(iter); if (nodo == NULL) return NULL; return nodo; }
void mostrar_registrados (vector_t *vectorzonas){ int i; pedido_t *auxpedido; lista_t* listaaux; int cantidad = vector_obtener_cantidad(vectorzonas); for (i=0; i<cantidad; i++){ listaaux = (lista_t*) vector_obtener(vectorzonas,i); printf("\n"); lista_iter_t *iter; iter=lista_iter_crear(listaaux); printf("Pedidos registrados de la zona %d\n", i+1); printf("Nombre cantidad zona\n"); while(lista_iter_al_final(iter)==false){ auxpedido=(pedido_t *)(lista_iter_ver_actual(iter)); printf("%s %d %d\n",auxpedido->nombre, auxpedido->cantidad, auxpedido->zona); if (auxpedido->preparado==true) printf ("Preparado\n"); lista_iter_avanzar(iter); } lista_iter_destruir(iter); } }
const char *hash_iter_ver_actual(const hash_iter_t *iter){ if (hash_iter_al_final(iter)) return NULL; daton_t* aux = lista_iter_ver_actual(iter->iter_lista); if (!aux) return NULL; return aux->clave; }
/* 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_iterar(lista_t *lista, bool (*visitar)(void *dato, void *extra), void *extra) { lista_iter_t* iter = lista_iter_crear(lista); void* dato = lista_iter_ver_actual(iter); while ((lista_iter_avanzar(iter)) && (visitar(dato, extra))) dato = lista_iter_ver_actual(iter); lista_iter_destruir(iter); }
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); }
void enviar(vector_t * vectorzonas, pila_t* pila){ lista_iter_t *iter,*iterborrar; bool primeroencontrado; int i,canti,cantf,total; pedido_t *pedidoaux,*primerpedido,*pedidof; lista_t* listaaux; for (i=0;i<vector_obtener_cantidad(vectorzonas);i++){ primeroencontrado=true; while(primeroencontrado) { primeroencontrado=false; canti=0; cantf=0; total=0; pedidof=NULL; listaaux= (lista_t*) vector_obtener(vectorzonas, i); iter=lista_iter_crear(listaaux); while ( !lista_iter_al_final(iter) ) { pedidoaux=(pedido_t*) (lista_iter_ver_actual(iter)); if (pedidoaux !=NULL) { if ( (!primeroencontrado) && (pedidoaux->preparado)) { primerpedido=pedidoaux; //primer pedido es el primer pedido preparado de esa zona canti=pedidoaux->cantidad; primeroencontrado=true; } else if (pedidoaux->preparado) { cantf=pedidoaux->cantidad; if ( ((canti + cantf)<=5) && ((canti+cantf)>total) ) { pedidof=pedidoaux; total=canti+cantf; } } } lista_iter_avanzar(iter); } lista_iter_destruir(iter); if ( (primeroencontrado) && (pedidof!=NULL)) printf("Se envio el pedido %s junto con el pedido %s \n",primerpedido->nombre,pedidof->nombre); else if (primeroencontrado){ printf("Se envio el pedido %s \n",primerpedido->nombre); } iterborrar=lista_iter_crear(listaaux); while (!lista_iter_al_final(iterborrar)) { if ( primerpedido==lista_iter_ver_actual(iterborrar) ) { pila_apilar(pila,primerpedido); lista_borrar(listaaux,iterborrar); } else{ if (pedidof==lista_iter_ver_actual(iterborrar)) { pila_apilar(pila,pedidof); lista_borrar(listaaux,iterborrar); } else lista_iter_avanzar(iterborrar); } } lista_iter_destruir(iterborrar); } } }