// Destruye el vector
// Pre: el vector fue creado
// Post: se eliminaron todos los elementos del vector
void vector_generico_destruir(vector_generico_t *vector, void destruir_dato(void *)){
if(destruir_dato)
for(size_t i = 0; i < vector->cant; i++)
destruir_dato(vector->datos[i]);
free(vector->datos);
free(vector);
}
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);
}
// Destruye la pila.
// Pre: la pila fue creada.
// Post: se eliminaron todos los elementos de la pila.
void pila_destruir(pila_t *pila , void destruir_dato(void *))
{
if (pila->cantidad != 0 || pila->datos != NULL)
if (destruir_dato)
destruir_dato(pila->datos);
free(pila->datos);
if (pila != NULL) free(pila);
}
// 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);
}
// Destruye la cola. Si se recibe la función destruir_dato por parámetro,
// para cada uno de los elementos de la cola llama a destruir_dato.
// Pre: la cola fue creada. destruir_dato es una función capaz de destruir
// los datos de la cola, o NULL en caso de que no se la utilice.
// Post: se eliminaron todos los elementos de la cola.
void cola_destruir(cola_t *cola, void destruir_dato(void*))
{
while (!cola_esta_vacia(cola))
if (destruir_dato != NULL)
destruir_dato(cola_desencolar(cola));
else
cola_desencolar(cola);
free(cola);
}
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);
}
void cola_destruir(cola_t *cola, void destruir_dato(void*)){
void* acceso_dato;
while (!cola_esta_vacia(cola)){
acceso_dato = cola_desencolar(cola);
if (destruir_dato != NULL)
destruir_dato(acceso_dato);
}
free (cola);
}
void cola_destruir(cola_t *cola, void destruir_dato(void*))
{
while( !cola_esta_vacia(cola) )
{
void *dato = cola_desencolar(cola);
if( destruir_dato )
destruir_dato(dato);
}
free(cola);
}
void pila_destruir(pila_t *pila , void destruir_dato(void *))
{
if (pila->datos != NULL) {
while (!pila_esta_vacia(pila)){
void* desapilado;
desapilado = pila_desapilar(pila);
if (destruir_dato)
destruir_dato(desapilado);
}
}
free(pila->datos);
free(pila);
}
void cola_destruir(cola_t *cola, void destruir_dato(void *)){
if (cola==NULL) return;
if (cola->prim == NULL){
free(cola);
return;
}
void* borrado;
int i;
for (i=0; i<cola->tamanio; i++){
borrado = cola_desencolar(cola);
if (destruir_dato!= NULL){
destruir_dato(borrado);
}
}
free(cola);
}
// Destruye la lista enlazada.
// PRE: 'lista' es una lista existente; 'destruir_dato' es una función
// que se encarga de destruir los datos (e.g.: free()). En caso de que
// los datos no necesiten ser destruidos se debe pasar NULL.
// POST: se eliminó la lista y todos sus elementos.
void lista_destruir(lista_t *lista, void destruir_dato(lista_dato_t)) {
nodo_lista_t* nodo;
// Recorremos los nodos y los destruimos
while(lista->primero) {
nodo = lista->primero;
lista->primero = nodo->sig;
// Si se especificó una función para destruir los datos,
// la usamos
if(destruir_dato) destruir_dato(nodo->dato);
free(nodo);
}
free(lista);
}
// Destruye la cola. Si se recibe la función destruir_dato por parámetro,
// para cada uno de los elementos de la cola llama a destruir_dato.
// Pre: la cola fue creada. destruir_dato es una función capaz de destruir
// los datos de la cola, o NULL en caso de que no se la utilice.
// Post: se eliminaron todos los elementos de la cola.
void cola_destruir(cola_t *cola, void destruir_dato(void*)){
if (destruir_dato == NULL){
while (cola->primero != NULL){
cola_desencolar(cola);
}
}
else{
while (cola->primero != NULL){
nodo_cola_t *nodo = cola->primero;
cola->primero = cola->primero->proximo;
destruir_dato(nodo->dato);
free(nodo);
}
}
free(cola);
}
// 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 cola_destruir(cola_t *cola, void (*destruir_dato)(void*)) {
if (cola != NULL) {
if (!cola_esta_vacia(cola)) {
struct nodo_cola* nodo = cola->primero;
struct nodo_cola* nodo_aux;
void* dato;
while (nodo != NULL) {
if (destruir_dato != NULL) {
dato = nodo->dato;
destruir_dato(dato);
}
nodo_aux = nodo->siguiente;
free(nodo);
nodo = nodo_aux;
}
}
free(cola);
}
}
/* 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);
}
