lunes, 24 de marzo de 2014

Listas enlazadas en C (II) .

Tal y como adelanté hace días, aquí una implementación más completa de listas enlazadas en C con métodos distintos a los que subí en esta entrada.
Os dejo el header y la implementación para que podáis descargarlas, aunque igualmente os lo pongo a continuación. Como veis también se incluye algo de manejo de ficheros, por lo que si no tenéis ni idea del tema os recomiendo ver la entrada de ayer en la que también se utilizan. Por último añadir que si veis algún fallo o tenéis alguna duda no tenéis más que decirlo. Un saludo (:


#ifndef LINKEDLIST_H_
#define LINKEDLIST_H_


struct _node;
typedef struct _node * Linked_List;
typedef struct _node{
 int value;
 Linked_List next;
} Node;


Linked_List create(); // Crea una lista enlazada vacía
void destroy(Linked_List * ptrL); // Libera la memoria de una lista
int is_empty(Linked_List l); // Devuelve verdadero si la lista está vacía
int contains(Linked_List l, int v); // Devuelve verdadero si la lista contiene el elemento v
int length(Linked_List l); // Devuelve el número de elementos de la lista
int insert(Linked_List * ptrL, int pos, int v); // Inserta v en la posición pos de la lista (*prtL).
            //Si ok, devuelve verdadero; si pos no está entre 0 y
            //length +1, entonces devuelve falso
int borrar(Linked_List * ptrL, int pos); // Borra el elemento pos de la lista, devolviendo verdadero
          // o falso según la operación se pueda realizar.
int getElement(Linked_List l, int pos); // Devuelve el elemento de la posición pos. Si esa posición
          // no existe, el comportamiento de la función no está definido.
Linked_List readFromFile(char * filename); // Asumiendo que filename contiene N líneas, donde cada línea
           // es un entero, lee el fichero y almacena su contenido
           //una lista que es devuelta como resultado. En caso de alguna
           //situación de error, la función devolverá NULL.
int writeToFile(Linked_List list, char * filename); // Escribe el contenido de la lista list en el fichero
             // denominado filaneme, almacenando cada elemento de la
             //lista una línea del fichero.  La función devuelve
             //verdadero o falso según se haya realizado con éxito o no


#endif /* LINKEDLIST_H_ */

Nota: No os asustéis por la extensión del código, pues gran parte son comentarios explicando el funcionamiento de los métodos.

#include <stdio.h>
#include <stdlib.h>
#include "ListasEnlazadas2.h"

Linked_List create(){
 Linked_List lista = NULL;
 return lista;
}

void destroy(Linked_List * ptrL){
 Linked_List auxiliar;
 while (*ptrL != NULL) {
  auxiliar=(*ptrL)->next;
  free(*ptrL);
  *ptrL=auxiliar;
 }
 /*
  Linked_List ptr = *ptrL;
   while(ptr != NULL){
     *ptrL = ptr->next;
     free(ptr);
     ptr = *ptrL;
   }
  */
}

int is_empty(Linked_List l){
 int bool = (l == NULL);
 return bool;
}

int contains(Linked_List l, int v){ // Devuelve verdadero si la lista contiene el elemento v
 Linked_List ptr = l;
 int bool = 0;
 while (ptr != NULL) {
  if(ptr-> value == v){
   bool = 1;
   break;
  }
  ptr = ptr->next;
 }
 return bool;
}
int length(Linked_List l){
 // Devuelve el número de elementos de la lista
 int contador = 0;
 while(l != NULL ){
  l = l -> next;
  contador++;
 }
 return contador;
}
int insert(Linked_List * ptrL, int pos, int v){
 // Inserta v en la posición pos de la lista (*prtL).
 //Si ok, devuelve verdadero; si pos no está entre 0 y
 //length +1, entonces devuelve falso
 Linked_List auxiliar;
 auxiliar = *ptrL;
 if(pos < 0 || pos > length(auxiliar)+1){
  return 0;
 }else{
  Linked_List  nodoanterior, ainsertar;
   int contador =0;
   nodoanterior = NULL;
   ainsertar=malloc(sizeof(struct _node));
   ainsertar -> value = v;

   while(auxiliar != NULL && contador < pos){
     nodoanterior = auxiliar;
     auxiliar = auxiliar -> next;

     contador++;
   }


   if(nodoanterior == NULL){ //tiene que ser el primero
    ainsertar->next = auxiliar; //lo meto al principio
    *ptrL = ainsertar;
   }else{
    ainsertar ->next = auxiliar;
    nodoanterior-> next = ainsertar;
   }
  return 1;
 }



}
int borrar(Linked_List * ptrL, int pos){
 // Borra el elemento pos de la lista, devolviendo verdadero
 // o falso según la operación se pueda realizar.
 int bool = 0;
 int contador = 0;
 Linked_List auxiliar, anterior, aux2;
 auxiliar = *ptrL;
 anterior = NULL;

 while(auxiliar != NULL && contador < pos){
  anterior = auxiliar;
  auxiliar = auxiliar -> next;

  contador++;
 }

 if(auxiliar!= NULL && contador == pos){
  bool = 1;
  if(anterior != NULL){ // no es el primer nodo
   anterior->next = auxiliar->next;
   free( auxiliar);
  }else{
   aux2 = auxiliar -> next;
   free(*ptrL);
   *ptrL = aux2;
  }

 }
 return bool;
}
int getElement(Linked_List l, int pos){
 // Devuelve el elemento de la posición pos. Si esa posición
 // no existe, el comportamiento de la función no está definido.
 int elemento; // Sale warning por no inicializar, pero no lo hacemos por no definir el comportamiento.
 int contador = 0;

 while(l != NULL && contador < pos){
  l = l -> next;
  contador++;
 }

 if(l != NULL && contador == pos){
  elemento = l -> value;
 }
 return elemento;
}
Linked_List readFromFile(char * filename){
 // Asumiendo que filename contiene N líneas, donde cada línea
 // es un entero, lee el fichero y almacena su contenido
 //una lista que es devuelta como resultado. En caso de alguna
 //situación de error, la función devolverá NULL.
 Linked_List l = create();
 FILE * f;
 int leido;
 int contador =0;
 if((f = fopen(filename, "r" )) != NULL){
  while (feof (f) == 0) {
   fscanf( f, " %d", &leido);
      insert(&l, contador, leido);
      contador ++;
  }
 }
 fclose (f);
 return l;
}
int writeToFile(Linked_List list, char * filename){
 // Escribe el contenido de la lista list en el fichero
 // denominado filaneme, almacenando cada elemento de la
 //lista una línea del fichero.  La función devuelve
 //verdadero o falso según se haya realizado con éxito o no
 int bool = 0;
 FILE * f;
 if((f = fopen(filename, "w")) != NULL){
  bool = 1;
  fprintf(f, "[");
  while(list != NULL){
   fprintf(f, "%d", list -> value);
   list = list->next;
   if (list != NULL) {
    fprintf(f, ", ");
   }
  }
  fprintf(f, "]");
 }
 return bool;
}
void mostrar (Linked_List lista){// Mostrar los elementos de la lista
 Linked_List ptr = lista;
 printf("[");
 while (ptr != NULL) {
  printf("%d", ptr->value);
  ptr = ptr->next;
  if (ptr != NULL) {
   printf(", ");
  }
 }
 printf("]\n");
}



int main(void) {
 Linked_List lista = readFromFile("text.txt");
 mostrar(lista);
 insert(&lista, 2, 5);
 mostrar(lista);
 writeToFile(lista, "salida.txt");
 // Probar todos los métodos como el usuario vea conveniente;)

 return EXIT_SUCCESS;
}


No hay comentarios:

Publicar un comentario