Lista c

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
/* ******************************************************************
 *                STRUCT NODO PARA LA LISTA
 * *****************************************************************/

typedef struct nodo{
    void* dato;
    struct nodo* proximo;

} nodo_t;

nodo_t* crear_nodo(void* valor){
    nodo_t* nodo = malloc(sizeof(nodo_t));
    nodo->dato = valor;
    nodo->proximo = NULL;
    return nodo;
    }

/* ******************************************************************
 *                STRUCT LISTA Y LISTA_ITER
 * *****************************************************************/


typedef struct lista
{
    nodo_t* primero;
    nodo_t* ultimo;
    size_t largo;
}lista_t;

typedef struct lista_iter
{
    lista_t* listaIT;
    nodo_t* actual;
    nodo_t* anterior;

}lista_iter_t;

/* ******************************************************************
 *                          PRIMITIVAS LISTA
 * *****************************************************************/

lista_t* lista_crear(void){

    lista_t* lista = malloc(sizeof(lista_t));
    if(!lista) return NULL;

    lista -> primero = NULL;
    lista -> ultimo = NULL;
    lista -> largo = 0;
    return lista;
}

bool lista_esta_vacia(const lista_t *lista){
    return lista->largo == 0;
}

void lista_vacia(lista_t* lista,nodo_t* dato){
    lista -> primero = dato;
    lista -> ultimo = dato;
}

bool lista_insertar_primero(lista_t* lista, void *dato){
    nodo_t* aux = crear_nodo(dato);
    if(!aux) return false;

    if(lista->largo == 0){
        lista_vacia(lista,aux);
    }
    else{
        aux->proximo = lista->primero;
        lista->primero = aux;
}
    lista -> largo++;
    return true;
}

bool lista_insertar_ultimo(lista_t* lista, void *dato){
    nodo_t* aux = crear_nodo(dato);
    if(!aux) return false;

    if (lista->largo == 0)
        lista_vacia(lista,aux);

    else{
        lista->ultimo->proximo = aux;
        lista -> ultimo = aux;
    }
    lista -> largo++;
    return true;
}


void* lista_borrar_primero(lista_t *lista){
    if(!lista->largo) return NULL;

    nodo_t*  nodo_aux = lista->primero;
    void* valor_a_borrar = nodo_aux->dato;
    nodo_t* nodo_aux_proximo = lista->primero->proximo;     // si la lista es 1 elem es NULL

    free(lista->primero);
    lista->primero = nodo_aux_proximo;
    if(!lista->primero)
        lista->ultimo = NULL;

    lista ->largo--;
    return valor_a_borrar;
}

void *lista_ver_primero(const lista_t *lista){
    if(!lista->largo) return NULL;
    return lista->primero->dato;
}

void *lista_ver_ultimo(const lista_t* lista){
    if(!lista->largo) return NULL;
    return lista->ultimo->dato;
}
size_t lista_largo(const lista_t *lista){
    return lista->largo;
}

void lista_destruir(lista_t *lista, void destruir_dato(void *)){

    while(!lista_esta_vacia(lista)){
        void* dato = lista_borrar_primero(lista);
        if(destruir_dato)
            destruir_dato(dato);
}
    free(lista);
}

/* ******************************************************************
 *                  PRIMITIVAS LISTA_ITER EXTERNAS
 * *****************************************************************/

lista_iter_t* lista_iter_crear(lista_t *lista){
    lista_iter_t* iter = malloc(sizeof(lista_iter_t));
    if (!iter) return NULL;
    iter -> actual = lista->primero;
    iter -> listaIT = lista;
    iter -> anterior = NULL;
    return iter;
}

bool lista_iter_avanzar(lista_iter_t *iter){
    if(!iter->actual) return false;

    nodo_t* aux = iter->actual->proximo;

    iter -> anterior = iter -> actual;
    iter -> actual = aux;
    return true;
}
bool lista_iter_al_final(const lista_iter_t *iter){
    if (!iter -> actual) return true;
    return false;
}

void* lista_iter_ver_actual(const lista_iter_t *iter){
    if (lista_iter_al_final(iter) || lista_esta_vacia(iter -> listaIT)) return NULL;
    return iter->actual->dato;
}

void lista_iter_destruir(lista_iter_t* iter){
    free(iter);
}


bool lista_iter_insertar(lista_iter_t *iter, void *dato){
    nodo_t* aux = crear_nodo(dato);
    if(!aux) return false;

    if(!iter->anterior){
        if(lista_esta_vacia(iter->listaIT))
            iter->listaIT->ultimo = aux;
        aux -> proximo = iter->listaIT->primero;
        iter -> listaIT -> primero = aux;
        iter->actual = aux;
    }
    else if(lista_iter_al_final(iter)){
        iter -> anterior -> proximo = aux;
        iter -> actual = aux;
        iter -> listaIT -> ultimo = aux;
    }
    else {
        aux -> proximo = iter -> actual;
        iter -> anterior -> proximo = aux;
        iter->actual = aux;
    }
    iter -> listaIT -> largo ++;
    return true;
}

void* lista_iter_borrar(lista_iter_t *iter){
    if (lista_esta_vacia(iter->listaIT) || lista_iter_al_final(iter)) return NULL;

    if(!iter->anterior){
        iter->actual = iter->actual->proximo;
        return lista_borrar_primero(iter->listaIT);
    }

    nodo_t* nodo_actual = iter->actual;
    void* dato = nodo_actual->dato;
    nodo_t* nodo_proximo = iter->actual->proximo;


    if(!iter->actual->proximo){
        iter->listaIT->ultimo = iter->anterior;
        free(iter->actual);
        iter->actual = NULL;
    }
    else{
        free(iter->actual);
        iter->anterior->proximo = nodo_proximo;
        iter->actual = nodo_proximo;
    }
    iter->listaIT->largo--;
    return dato;
    }

/* ******************************************************************
 *                  PRIMITIVA LISTA_ITER INTERNA
 * *****************************************************************/

void lista_iterar(lista_t* lista, bool(*visitar)(void*,void*), void* extra){
    nodo_t* lista_aux = lista->primero;
    bool condicion = true;

    while(condicion && lista_aux){

        void* dato = lista_aux -> dato;
        condicion=visitar(dato,extra);
        nodo_t* proximo = lista_aux->proximo;
        lista_aux = proximo;
    }
}