// 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); }