void *lista_borrar_primero(lista_t *lista) {
if (lista_esta_vacia(lista)) return NULL;
nodo_t* nodo_a_borrar = lista->inicio;
void* elemento = nodo_a_borrar->valor;
lista->inicio = nodo_a_borrar->siguiente;
lista->largo--;
if (lista_esta_vacia(lista)) lista->fin = NULL;
free(nodo_a_borrar);
return elemento;
}
// Borra de la lista el elemento en donde se encuentra el iterador y
// devuelve su valor. Devuelve NULL en caso de estar al final de la lista
// o que la lista esté vacía.
// Pre: la lista y el iterador fueron creados
// Post: Se elminó un elemento de la lista y se devolvió su valor.
void *lista_borrar(lista_t *lista, lista_iter_t *iter)
{
/* Retornamos NULL si esta al final de la lista */
if (lista_iter_al_final(iter) || lista_esta_vacia(lista))
return NULL;
/* Retornamos lista_borrar_primero si el iterador está al comienzo
* de la lista */
if (!iter->anterior){
iter->actual = lista->primero->prox;
return lista_borrar_primero(lista);
}
/* Creamos variables auxiliares para guardar su dato y liberarla */
nodo_t* nodo_aux = iter->actual;
void* dato_aux = nodo_aux->dato;
/* Ubicamos el iterador en su nueva posicion actual */
iter->actual = iter->actual->prox;
iter->anterior->prox = iter->actual;
if (!iter->actual)
lista->ultimo = iter->anterior;
lista->cantidad--;
free(nodo_aux);
return dato_aux;
}
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;
}
void *lista_borrar(lista_t *lista, lista_iter_t *iter) {
void* dato_borrado;
// Si la lista está vacía o recorrí toda la lista
if (lista_esta_vacia(lista) || lista_iter_al_final(iter)) return NULL;
// Si estoy en la primera posición del iterador
else if (!iter->anterior) {
dato_borrado = lista_borrar_primero(lista);
iter->actual = lista->inicio;
}
// Si estoy en cualquier otra posición del iterador
else {
nodo_t *nodo_a_borrar = iter->actual;
dato_borrado = nodo_a_borrar->valor;
// Si estoy al final de la lista
if (!iter->actual->siguiente) {
iter->anterior->siguiente = NULL;
iter->actual = NULL;
lista->fin = iter->anterior;
}
// Si estoy en cualquier otra posición
else {
iter->anterior->siguiente = nodo_a_borrar->siguiente;
iter->actual = nodo_a_borrar->siguiente;
}
free(nodo_a_borrar);
lista->largo--;
}
return dato_borrado;
}
void *lista_borrar(lista_t *lista, lista_iter_t *iter)
{
if (lista_esta_vacia(lista)) return NULL;
nodo_t* puntero_auxiliar = iter->actual;
void* dato_auxiliar = puntero_auxiliar->valor;
if (iter->actual) iter->actual = (iter->actual)->ref;
else return NULL;
// Caso particular: borrar el primer elemento de la lista
if (!(iter->anterior))
lista->inicio = (lista->inicio)->ref;
else {
(iter->anterior)->ref = iter->actual;
// Caso particular: borra el ultimo elemento de la lista
if (!(iter->actual)) lista->fin = iter->anterior;
}
free (puntero_auxiliar);
lista->largo -= 1;
if (lista->largo == 0) lista->fin = NULL;
return dato_auxiliar;
}
void lista_destruir(lista_t *lista, void destruir_dato(void *)) {
while (!lista_esta_vacia(lista)) {
void* elemento = lista_borrar_primero(lista);
if (destruir_dato) destruir_dato(elemento);
}
free(lista);
}
void lista_destruir(lista_t *lista, void destruir_dato(void *)){
while (!lista_esta_vacia(lista)){
if (destruir_dato) destruir_dato(lista->primero->dato);
lista_borrar_primero(lista);
}
free(lista);
}
// Elimina un elemento de la lista en la posicion actual del iterador
// Pre: el iterador y la lista fueron creados
// Post: devuelve un puntero al dato del nodo que fue borrado o NULL si algun parametro no es correcto
void* lista_borrar(lista_t *lista, lista_iter_t *iter)
{
if(!lista || !iter || lista_iter_al_final(iter) || lista_esta_vacia(lista))
return NULL;
nodo_t *nodo = iter->nodo_act;
void *dato = nodo->dato;
// Caso 1: Iter al principio de la lista
if(iter->nodo_ant == NULL)
{
lista->primero = iter->nodo_act->siguiente;
iter->nodo_act = lista->primero;
}
else
{
iter->nodo_ant->siguiente = iter->nodo_act->siguiente;
iter->nodo_act = iter->nodo_ant->siguiente;
}
free(nodo);
lista->largo--;
if(lista_largo(lista)==1)
lista->ultimo = lista->primero;
return dato;
}
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;
}
lista_iter_t *lista_iter_crear(const lista_t *lista)
{
if (lista_esta_vacia(lista)) return NULL;
lista_iter_t* iter = malloc(sizeof(lista_iter_t));
iter->anterior = NULL;
iter->actual = lista->inicio;
return iter;
}
bool lista_insertar_primero(lista_t *lista, void *dato){
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
nodo->siguiente = lista->primero;
if (lista_esta_vacia(lista)) lista->ultimo = nodo;
lista->primero = nodo;
lista->largo++ ;
return true;
}
// Destruye la lista. Si se recibe la función destruir_dato por parámetro,
// para cada uno de los elementos de la lista llama a destruir_dato.
// Pre: la lista fue creada. destruir_dato es una función capaz de destruir
// los datos de la lista, o NULL en caso de que no se la utilice.
// Post: se eliminaron todos los elementos de la lista.
void lista_destruir(lista_t *lista, void destruir_dato(void*))
{
while(!lista_esta_vacia(lista))
if(destruir_dato!=NULL)
destruir_dato(lista_borrar_primero(lista));
else
lista_borrar_primero(lista);
free(lista);
}
void *lista_borrar_primero(lista_t *lista){
if (lista_esta_vacia(lista)) return NULL;
void* dato_salida = lista->primero->dato;
nodo_t* aux = lista->primero->siguiente;
free(lista->primero) ;
lista->primero = aux;
lista->largo --;
if (!lista->primero) lista->ultimo = NULL;
return dato_salida;
}
void lista_destruir(lista_t *lista, void destruir_dato(void *)){
if (lista==NULL) return;
while (!lista_esta_vacia(lista)){
void *borrado = lista_borrar_primero(lista);
if (destruir_dato!= NULL){
destruir_dato(borrado);
}
}
free(lista);
}
int sesion_aplicar(sesion_t* sesion,base_t* basedatos){
inscripcion_t* anotado;
if (strcmp(sesion->padron,"00000")==0) return -1;
while(!lista_esta_vacia(sesion->inscripciones)){
anotado = (inscripcion_t*)lista_borrar_primero(sesion->inscripciones);
inscribir(sesion->padron,anotado->curso,basedatos);
destruir_inscripcion(anotado);
}
strcpy(sesion->padron,"00000");
return 0;
}
bool lista_insertar_ultimo(lista_t *lista, void *dato) {
nodo_t* nodo = nodo_crear(dato);
if (!nodo) return false;
if (lista_esta_vacia(lista)) {
lista->inicio = nodo;
lista->fin = nodo;
}
lista->fin->siguiente = nodo;
lista->fin = nodo;
lista->largo++;
return true;
}
void *lista_borrar_primero(lista_t *lista){
if (lista_esta_vacia(lista)) return NULL;
nodo_t *nodo_a_borrar = lista->inicio;
void *valor = nodo_a_borrar->valor;
lista->inicio= (nodo_a_borrar)->ref;
free(nodo_a_borrar);
lista->largo -=1;
if (lista->largo == 0) lista->fin = NULL;
return valor;
}
// Saca el primer elemento de la lista. Si la lista tiene elementos, se quita el
// primero de la lista, y se devuelve su valor, si está vacía, devuelve NULL.
// Pre: la lista fue creada.
// Post: se devolvió el valor del primer elemento anterior, la lista
// contiene un elemento menos, si la lista no estaba vacía.
void* lista_borrar_primero(lista_t *lista)
{
if(lista_esta_vacia(lista))
return NULL;
void* dato = lista_ver_primero(lista);
nodo_t* nuevo_primero = lista->primero->siguiente;
free(lista->primero);
lista->largo--;
lista->primero = nuevo_primero;
return dato;
}
// Saca el primer elemento de la lista. Si la lista tiene elementos,
// se quita el primero de la lista, y se devuelve su valor, si está
// vacía, devuelve NULL.
// Pre: la lista fue creada.
// Post: se devolvió el valor del primer elemento anterior, la lista
// contiene un elemento menos, si la lista no estaba vacía.
void *lista_borrar_primero(lista_t *lista)
{
/* Verificamos si está vacía */
if (lista_esta_vacia(lista))
return NULL;
/* Realizamos las modificaciones a la lista */
nodo_t *nodo_aux = lista->primero;
void *dato_aux = lista_ver_primero(lista);
lista->primero = nodo_aux->prox;
free(nodo_aux);
lista->cantidad--;
return dato_aux;
}
bool lista_insertar_primero(lista_t *lista, void *dato){
nodo_t* nuevo_nodo = nodo_crear(dato);
if (nuevo_nodo == NULL) return false;
if (lista_esta_vacia(lista)){
lista->inicio = nuevo_nodo;
lista->fin = nuevo_nodo;
}
else{
nuevo_nodo->ref = lista->inicio;
lista->inicio = nuevo_nodo;
}
lista->largo += 1;
return true;
}
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;
}
// Agrega un nuevo elemento al principio de la lista. Devuelve falso
// men caso de error.
// Pre: la lista fue creada.
// Post: se agregó un nuevo elemento a la lista, dato se encuentra al inicio
// de la lista.
bool lista_insertar_primero(lista_t *lista, void *dato)
{
nodo_t* nodo_nuevo = crear_nodo(dato);
if (!nodo_nuevo)
return false;
/*Si la lista esta vacía el nodo será el primero y último de la lista. */
if (lista_esta_vacia(lista))
insertar_lista_vacia(lista, nodo_nuevo);
else{
/* Asignamos a la primer posicion al nuevo nodo */
nodo_nuevo->prox = lista->primero;
lista->primero = nodo_nuevo;
}
lista->cantidad++;
return true;
}
// Agrega un nuevo elemento al principio 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 principio
// de la lista.
bool lista_insertar_primero(lista_t *lista, void* valor)
{
nodo_t* nodo = malloc(sizeof(nodo_t));
if(nodo == NULL)
return false;
lista->largo++;
nodo->siguiente = lista->primero;
nodo->dato = valor;
if(lista_esta_vacia(lista))
lista->ultimo = nodo;
lista->primero = nodo;
return true;
}
bool hash_iter_avanzar(hash_iter_t* iter) {
//verifico no estar ya al final
if (hash_iter_al_final(iter)) return false;
//avanzo y verifico no estar ahora al final
lista_iter_avanzar(iter->iter);
if (!lista_iter_al_final(iter->iter)) return true;
//como estoy al final de la lista, busco si tengo a donde seguir
if (iter->posicion == (iter->hash->tamanio)-1) return false;
//como lo tengo, busco
size_t posicion = buscar_no_vacia(iter->hash,iter->posicion+1);
if (!lista_esta_vacia(iter->hash->tabla[posicion])) {
lista_iter_destruir(iter->iter);
iter->iter = lista_iter_crear(iter->hash->tabla[posicion]);
iter->posicion = posicion;
return true;
}
return false;
}
// 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, dato se encuentra al final
// de la lista.
bool lista_insertar_ultimo(lista_t *lista, void *dato)
{
/* Creamos el nuevo nodo. */
nodo_t* nodo_nuevo = crear_nodo(dato);
if (!nodo_nuevo)
return false;
/*Si la lista esta vacía el nodo será el primero y último de la lista. */
if (lista_esta_vacia(lista))
insertar_lista_vacia(lista, nodo_nuevo);
else{
/* Obtenemos el ultimo nodo y le agregamos el nuevo nodo al miembro prox. */
lista->ultimo->prox = nodo_nuevo;
lista->ultimo = nodo_nuevo;
}
lista->cantidad++;
return true;
}
void lista_destruir2(lista_t* lista, hash_destruir_dato_t destruir_dato){ // Funcion que cree parecida a la de la lista, ya que la otra no me servia
if (lista_esta_vacia(lista)){
free(lista);
return;
}
if (destruir_dato){
daton_t* aux = lista_borrar_primero(lista);
free(aux->clave);
destruir_dato(aux->dato);
free(aux);
lista_destruir2(lista, destruir_dato);
return;
}
daton_t* aux2 = lista_borrar_primero(lista);
free(aux2->clave);
free(aux2);
lista_destruir2(lista, destruir_dato);
}
// Destruye la lista. Si se recibe la función destruir_dato por parámetro,
// para cada uno de los elementos de la lista llama a destruir_dato.
// Pre: la lista fue creada. destruir_dato es una función capaz de destruir
// los datos de la lista, o NULL en caso de que no se la utilice.
// Post: se eliminaron todos los elementos de la lista.
void lista_destruir(lista_t *lista, void destruir_dato(void *))
{
/* Declaro nodo_aux para recorrer la cola y nodo_para_destruir para
* guardar el nodo que será destruido. */
nodo_t *nodo_aux = lista->primero, *nodo_para_destruir;
while(nodo_aux){
/* Destruimos el dato del nodo si se recibe destruir_dato */
if (destruir_dato && !lista_esta_vacia(lista))
destruir_dato(nodo_aux->dato);
nodo_para_destruir = nodo_aux;
nodo_aux = nodo_aux->prox;
free(nodo_para_destruir);
}
free(lista);
}
void *hash_borrar(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_borrar(iter_l);
void* dato_salida = aux->dato;
free(aux->clave);
free(aux);
hash->tam--;
lista_iter_destruir(iter_l);
if (lista_esta_vacia(hash->tabla[indice])){
lista_destruir(hash->tabla[indice], NULL);
hash->tabla[indice] = NULL;
}
if (hash->tam < 3 * hash->largo && hash->largo > TAM_INI) {
unsigned long nuevo_largo = hash->largo / 2;
redimensionar(hash, nuevo_largo);
}
return dato_salida;
}
/* 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_ver_primero(const lista_t *lista) {
if (!lista_esta_vacia(lista)) return lista->inicio->valor;
return NULL;
}
