insertar un nodo después de otro

[minette1988]

Hola, tengo el siguiente programa que me permite añadir al principio, al final, recorrer la lista y mostrarla por pantalla, borrar un nodo. Lo que no me deja es insertar un nodo después de otro.

Pongo un ejemplo: Miguel Angel 25, Gloria 32, Pablo 50
Borro Gloria 32 y quiero insertar un nuevo nodo entre el primero y el tercero, ya que he borrado el segundo.
Espero que puedan ayudrame, gracias.
Este es el programa:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LEE_CAD(c,n) { int i=0; \
                     c[i]=getchar();\
     while((c[i]=='\n') || (c[i]=='\t')) c[i]=getchar();\
     while ((c[i]!='\n') && (i < (n-1))){ \
        i++;\
c[i]=getchar(); }\
     c[i]='\0'; }

#define T_NOM 101
#define T_EDAD 3


struct persona {
char nom[100];
        char edad[3];
struct persona *siguiente;
};

int main(){
         struct persona *lista=NULL;
         struct persona *nodo;

         int op;
         void alta_inicio();
         void alta_final();
         void alta_despues_de();
         void recorrer_lista();
         void borrar_nodo();
         struct persona * buscar_nodo();
         
         do{
            do{
               printf("Elija una opción:\n");
               printf("1--> Añadir al principio.\n");
               printf("2--> Añadir al final.\n");
               printf("3--> Recorrer la lista.\n");
               printf("4--> Buscar nodo.\n");
               printf("5--> Eliminar nodo.\n");
               printf("6--> Añadir despues de...\n");
               printf("7--> Salir.\n");
               scanf("%d",&op);
            }while((op < 1) || (op > 7));
         if(op != 4)   
            switch(op){
                case 1: { alta_inicio(&lista);break;}
                case 2: { alta_final(&lista);break;}
                case 3: { recorrer_lista(&lista);break;}
                case 4: { nodo=buscar_nodo(&lista);
                          printf("\n%s\n",nodo->nom);break;}
                case 5: { borrar_nodo(&lista);break;}
                case 6: { alta_despues_de(&lista);break;}
            }
         }while(op != 7);
         exit(0);
}
////////////////////////////////////////////////////////////////////////////
void alta_inicio(struct persona **lista){
         struct persona *nuevo_nodo;
         nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));
         if(nuevo_nodo != NULL){
            nuevo_nodo->siguiente = *lista;
            *lista = nuevo_nodo;
            printf("Nombre: ");
            LEE_CAD(nuevo_nodo->nom,T_NOM);
            printf("Edad: ");
            LEE_CAD(nuevo_nodo->edad,T_EDAD);
         }
}             
////////////////////////////////////////////////////////////////////////////////
void recorrer_lista(struct persona **lista){
          struct persona *nodo_aux;
          nodo_aux = *lista;
          while(nodo_aux != NULL){
               printf("%s\n",nodo_aux->nom);
               printf("%s\n",nodo_aux->edad);
               nodo_aux = nodo_aux->siguiente;
          }
}
//////////////////////////////////////////////////////////////////////////////
void alta_final(struct persona **lista){
          struct persona *nuevo_nodo;
          struct persona *nodo_aux;

          nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));
          if(nuevo_nodo != NULL){
             nodo_aux = *lista;
             while(nodo_aux->siguiente != NULL)
                nodo_aux = nodo_aux->siguiente;
                nodo_aux->siguiente=nuevo_nodo;
                nuevo_nodo->siguiente=NULL;
                printf("Nombre del nuevo elemento: ");
                LEE_CAD(nuevo_nodo->nom,T_NOM);
                printf("Edad del nuevo elemento: ");
                LEE_CAD(nuevo_nodo->edad,T_EDAD);
          }
          else
               printf("Error al tomar memoria del nuevo nodo.\n");
}
/////////////////////////////////////////////////////////////////////////////////
struct persona *buscar_nodo(struct persona **lista){
          struct persona *nodo_aux, *resultado;
          char nom[100];
          char edad[3];
          int encontrado = 0;

          printf("Nombre a buscar: ");
          scanf("%99s",nom);
         
          nodo_aux = *lista;
          while((nodo_aux->siguiente != NULL) && (!encontrado)){
                if(strcmp(nom,nodo_aux->nom) == 0)
                  encontrado = 1;
                else
                    nodo_aux = nodo_aux->siguiente;
          }
          if((nodo_aux->siguiente == NULL) && (!encontrado))
              if(strcmp(nom,nodo_aux->nom) == 0)
                 encontrado = 1;
          if(encontrado)
            resultado = NULL;
          return(resultado);

          printf("Edad a buscar: ");
          scanf("%2s",edad);
         
          nodo_aux = *lista;
          while((nodo_aux->siguiente != NULL) && (!encontrado)){
                if(strcmp(edad,nodo_aux->edad) == 0)
                  encontrado = 1;
                else
                    nodo_aux = nodo_aux->siguiente;
          }
          if((nodo_aux->siguiente == NULL) && (!encontrado))
              if(strcmp(edad,nodo_aux->edad) == 0)
                 encontrado = 1;
          if(encontrado)
            resultado = NULL;
          return(resultado);
}
////////////////////////////////////////////////////////////////////////////////
void borrar_nodo(struct persona **lista){
          struct persona *nodo_aux, *nodo_anterior;
          char nom[100];
          char edad[3];
          int encontrado = 0;

          printf("Nombre a borrar: ");
          scanf("%99s",nom);
          nodo_aux = *lista;

          if(strcmp(nom,nodo_aux->nom) == 0){
            *lista=nodo_aux->siguiente;
            free(nodo_aux);}
          else{
               nodo_anterior = nodo_aux;
               nodo_aux = nodo_aux->siguiente;
               while((nodo_aux->siguiente != NULL) && (!encontrado)){
                   if(strcmp(nom,nodo_aux->nom) == 0)         
                     encontrado = 1;
                   else{
                      nodo_anterior = nodo_aux;
                      nodo_aux = nodo_aux->siguiente;
                   }
               } 
               if((nodo_aux->siguiente == NULL) && (!encontrado))
                  if(strcmp(nom,nodo_aux->nom) == 0)
                     encontrado = 1;
               if(encontrado){
                  nodo_anterior->siguiente = nodo_aux->siguiente;
                  free(nodo_aux);
               }
          }
          printf("Edad a borrar: ");
          scanf("%2s",edad);
          nodo_aux = *lista;

          if(strcmp(edad,nodo_aux->edad) == 0){
            *lista=nodo_aux->siguiente;
            free(nodo_aux);}
          else{
               nodo_anterior = nodo_aux;
               nodo_aux = nodo_aux->siguiente;
               while((nodo_aux->siguiente != NULL) && (!encontrado)){
                   if(strcmp(edad,nodo_aux->edad) == 0)         
                     encontrado = 1;
                   else{
                      nodo_anterior = nodo_aux;
                      nodo_aux = nodo_aux->siguiente;
                   }
               } 
               if((nodo_aux->siguiente == NULL) && (!encontrado))
                  if(strcmp(edad,nodo_aux->edad) == 0)
                     encontrado = 1;
               if(encontrado){
                  nodo_anterior->siguiente = nodo_aux->siguiente;
                  free(nodo_aux);
               }
          }
}
///////////////////////////////////////////////////////////////////////////////
void alta_despues_de(struct persona **lista){
           struct persona *nuevo_nodo;
           struct persona *nodo_aux;
           char nom[100];
           char edad[3];
           int encontrado = 0;
           
           printf("Nombre a buscar para insertar después de el: ");
           scanf("%99s",nom);
           
           nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));

           if(nuevo_nodo != NULL){
             nodo_aux = *lista;
             while((nodo_aux->siguiente != NULL) && (!encontrado)){
                  if(strcmp(nom,nodo_aux->nom) == 0)
                     encontrado = 1;
                  else{
                       nodo_aux = nodo_aux->siguiente;
                  }
             }
             if((nodo_aux->siguiente == NULL) && (!encontrado))
                if(strcmp(nom,nodo_aux->nom) == 0)
                  encontrado = 1;

             if(encontrado){
                nuevo_nodo->siguiente=nodo_aux->siguiente;
                nodo_aux->siguiente=nuevo_nodo;
                printf("Nombre del nuevo elemento: ");
                scanf("%99s",nuevo_nodo->nom);
             }
             else{
                  printf("Elemento no encontrado.\n");
                  free(nuevo_nodo);
             }
           }
           printf("Edad a buscar para insertar después de el: ");
           scanf("%2s",edad);

           nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));

           if(nuevo_nodo != NULL){
             nodo_aux = *lista;
             while((nodo_aux->siguiente != NULL) && (!encontrado)){
                  if(strcmp(edad,nodo_aux->edad) == 0)
                     encontrado = 1;
                  else{
                       nodo_aux = nodo_aux->siguiente;
                  }
             }
             if((nodo_aux->siguiente == NULL) && (!encontrado))
                if(strcmp(edad,nodo_aux->edad) == 0)
                  encontrado = 1;

             if(encontrado){
                nuevo_nodo->siguiente=nodo_aux->siguiente;
                nodo_aux->siguiente=nuevo_nodo;
                printf("Edad del nuevo elemento: ");
                scanf("%2s",nuevo_nodo->edad);
             }
             else{
                  printf("Elemento no encontrado.\n");
                  free(nuevo_nodo);
             }
           }
}

[Og.]

No me puse a leer tu code, pero si quieres meter un  nuevo registro en el espacio 2 seria algo asi:

si el primer campo de la lista lo dejaste como nulo solo para tener referencia a este,

Código (cpp) [Seleccionar] Expandir

int a = 2;
presona *nuevo, *prev = &lista, *ll = &lista;
ll = ll->siguiete;
cin >> nuevo->nom >> nuevo->edad;
while(a--)
{
    prev = ll;
    ll = ll->siguiente;
}
prev->siguente = nuevo;
nuevo->siguiente = ll;

Ojala te sirva de algo.

[minette1988]

Hola, ya lo he solucionado, pero quiero publicar otra vez el código con las modificaciones que he hecho para que puedan decirme cómo puedo guardar esta lista enlazada a un fichero binario y una vez guardado poder abrirlo para leer su contenido. Agradecería que me ayudaran, ya que en esto de los ficheros ando perdida. Gracias.

Código (c) [Seleccionar] Expandir

/* Implementación de una lista enlazada */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define LEE_CAD(c,n) { int i=0; \
                     c[i]=getchar();\
     while((c[i]=='\n') || (c[i]=='\t')) c[i]=getchar();\
     while ((c[i]!='\n') && (i < (n-1))){ \
        i++;\
c[i]=getchar(); }\
     c[i]='\0'; }

#define T_NOM 101
#define T_TEL 10


struct nodo_lista{
   char nombre[T_NOM];
   char telefono[T_TEL];
   struct nodo_lista * siguiente; /*Puntero al siguiente elemento de la lista*/
};

int main(){
  struct nodo_lista *lista = NULL; /* Puntero al inicio de la lista, vacía */
  struct nodo_lista *nodo;
                               
  int op; /* Variable para tomar la opción del menú del programa */
 
  void alta_inicio();
  void alta_final();
  void alta_despues_de();
  void mostrar_lista();
  void ordenar();
  void borrar_nodo();


  struct nodo_lista * buscar_nodo_nombre(); /* Devuelve un puntero al nodo buscado */
  struct nodo_lista * buscar_nodo_telefono();


  do{
    do{
       printf("1--> Añadir al Principio.\n");
       printf("2--> Añadir al Final.\n");
       printf("3--> Añadir después de.\n");
       printf("4--> mostrar el total de la lista.\n");
       printf("5--> Buscar (nodo)nombre para saber el telefono.\n");
       printf("6--> Buscar (nodo)telefono para saber el nombre.\n");
       printf("7--> Eliminar nodo.\n");
       printf("8--> ordenar filas alfabeticamente\n");
       printf("9--> Salir.\n");
       scanf("%d",&op);
     }while((op < 1) || (op > 9));
     if( op != 9)
       switch(op){
          case 1: { alta_inicio(&lista); break;}
          case 2: { alta_final(&lista); break;}
          case 3: { alta_despues_de(&lista);break;}
          case 4: { mostrar_lista(&lista); break;}
          case 5: { nodo = buscar_nodo_nombre(&lista);
                    printf("\n%s\n",nodo->telefono);
                    break;}
          case 6: { nodo = buscar_nodo_telefono(&lista);
                    printf("\n%s\n",nodo->nombre);
                    break;}
          case 7: { borrar_nodo(&lista); break;}
  case 8: { ordenar(&lista);break;}
       }
  }while(op != 9);
}
////////////////////////////////////////////////////////////////////
void alta_inicio(struct nodo_lista **lista){   
  struct nodo_lista *nuevo_nodo; /* Variable usada para crear nuevos nodos
                                    que serán añadidos a la lista */       
       
  /* Creamos un nodo con malloc()*/     
  nuevo_nodo=(struct nodo_lista *)malloc(sizeof(struct nodo_lista));
  if (nuevo_nodo != NULL){
 
    /* Lo ponemos la principio */
    nuevo_nodo->siguiente = *lista; /* Apunta al elemento que pasará a ser el
                                    segundo de la lista */
    *lista = nuevo_nodo; /* El inicio de la lista apunta al nuevo nodo */
    /* Tomamos el dato del nuevo nodo */
 
    printf("Nombre: ");
    LEE_CAD(nuevo_nodo->nombre,T_NOM);   
    printf("Telefono: ");
    LEE_CAD(nuevo_nodo->telefono,T_TEL);   
  }
  else
    printf("Error al tomar memoria para el nuevo nodo.\n");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mostrar_lista(struct nodo_lista **lista){
  struct nodo_lista *nodo_aux; /* Nodo auxiliar para recorrer la lista */

  nodo_aux = *lista;
  while ( nodo_aux != NULL){
     printf("%s  %s\n",nodo_aux->nombre,nodo_aux->telefono);
     nodo_aux = nodo_aux->siguiente; /* El nodo auxiliar ahora apunta al
                                        elemento siguiente */
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////
void alta_final(struct nodo_lista **lista){
  struct nodo_lista *nuevo_nodo; /* Variable usada para crear nuevos nodos
                                    que serán añadidos a la lista */
  struct nodo_lista *nodo_aux; /* Nodo auxiliar para recorrer la lista */

  /* Creamos un nodo con malloc()*/
  nuevo_nodo=(struct nodo_lista *)malloc(sizeof(struct nodo_lista));
  if (nuevo_nodo != NULL){
    nodo_aux = *lista;
    while (nodo_aux->siguiente != NULL) /* Vamos al final de la lista */
      nodo_aux = nodo_aux->siguiente; /* El nodo auxiliar ahora apunta al
                                        elemento siguiente */
    nodo_aux->siguiente=nuevo_nodo; /* El que era el último ahora apunta al
                                       nodo nuevo que será el último */
    nuevo_nodo->siguiente=NULL;
    printf("Nombre del nuevo elemento: ");
    LEE_CAD(nuevo_nodo->nombre,T_NOM);
    printf("Telefono del nuevo elemento: ");
    LEE_CAD(nuevo_nodo->telefono,T_TEL);
  }
  else
    printf("Error al tomar memoria para el nuevo nodo.\n");
}
/////////////////////////////////////////////////////////////////////////////////////////////
void alta_despues_de(struct nodo_lista **lista){
   struct nodo_lista *nuevo_nodo;
   struct nodo_lista *nodo_aux;

   char nombre[T_NOM];
   char telefono[T_TEL];
   int encontrado = 0;

   printf("Nombre a buscar para insertar después de él: ");
   LEE_CAD(nombre,T_NOM);
   printf("Telefono a buscar para insertar después de él: ");
   LEE_CAD(telefono,T_TEL);
   nuevo_nodo=(struct nodo_lista *)malloc(sizeof(struct nodo_lista));

   if(nuevo_nodo != NULL){
      nodo_aux = *lista;
      while((nodo_aux->siguiente != NULL) && (!encontrado)){
        if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0))
          encontrado = 1;
        else{
             nodo_aux = nodo_aux->siguiente;
        }
      }
   }
   if((nodo_aux->siguiente == NULL) && (!encontrado))
       if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0))
          encontrado = 1;

       if(encontrado){
          nuevo_nodo->siguiente=nodo_aux->siguiente;
          nodo_aux->siguiente=nuevo_nodo;
          printf("Nombre del nuevo elemento: ");
          LEE_CAD(nuevo_nodo->nombre,T_NOM);
          printf("Telefono del nuevo elemento: ");
          LEE_CAD(nuevo_nodo->telefono,T_TEL);
      }
      else{
           printf("Elemento no encontrado.\n");
           free(nuevo_nodo);
      }
}
//////////////////////////////////////////////////////////////////////////////////////////////
struct nodo_lista * buscar_nodo_nombre(struct nodo_lista **lista){
    struct nodo_lista *nodo_aux, *resultado; /* Nodo auxiliar para recorrer la lista */
    char nombre[T_NOM]; /* Nombre a buscar en la lista */
    int encontrado = 0; /* Si encuentra el nodo se pone a 1 */
    printf("Nombre a buscar: ");
    LEE_CAD(nombre,T_NOM);

    nodo_aux = *lista;
    /* Mientras no se llegue al final de la lista o se encuentre el nombre
       avanza en la lista */
    while((nodo_aux->siguiente != NULL) && (!encontrado)){
      if(strcmp(nombre,nodo_aux->nombre) == 0) /* Iguales */
         encontrado = 1;
      else
         nodo_aux = nodo_aux->siguiente;
    }
    /* Comprueba si el último de la lista es el elemento buscado */
    if((nodo_aux->siguiente == NULL) && (!encontrado))
       if(strcmp(nombre,nodo_aux->nombre) == 0) /* Iguales */
         encontrado = 1;

    if(encontrado)
      resultado = nodo_aux;
    else /* Si no lo encuentra devuelve NULL */
      resultado = NULL;
    return(resultado);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct nodo_lista * buscar_nodo_telefono(struct nodo_lista **lista){
    struct nodo_lista *nodo_aux, *resultado; /* Nodo auxiliar para recorrer la lista */
    char telefono[T_TEL]; /* Nombre a buscar en la lista */
    int encontrado = 0; /* Si encuentra el nodo se pone a 1 */
    printf("Telefono a buscar: ");
    LEE_CAD(telefono,T_TEL);

    nodo_aux = *lista;
    /* Mientras no se llegue al final de la lista o se encuentre el nombre
       avanza en la lista */
    while((nodo_aux->siguiente != NULL) && (!encontrado)){
      if(strcmp(telefono,nodo_aux->telefono) == 0) /* Iguales */
         encontrado = 1;
      else
         nodo_aux = nodo_aux->siguiente;
    }
    /* Comprueba si el último de la lista es el elemento buscado */
    if((nodo_aux->siguiente == NULL) && (!encontrado))
       if(strcmp(telefono,nodo_aux->telefono) == 0) /* Iguales */
         encontrado = 1;

    if(encontrado)
      resultado = nodo_aux;
    else /* Si no lo encuentra devuelve NULL */
      resultado = NULL;
    return(resultado);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
void borrar_nodo(struct nodo_lista **lista){
    /* Para borrar un nodo, tendremos que guardar un puntero al nodo anterior
       del que nos encontramos, ya que este puntero pasará a apuntar al nodo
       apuntado por el que vamos a borrar */
    struct nodo_lista *nodo_aux, *nodo_anterior;
    char nombre[T_NOM];
    char telefono[T_TEL];
    int encontrado = 0;

    printf("Nombre a borrar: ");
    LEE_CAD(nombre,T_NOM);
    printf("Telefono a borrar: ");
    LEE_CAD(telefono,T_TEL);
    nodo_aux = *lista;
    /* Comprueba si el elemento a borrar es el primero de la lista */
    if((strcmp(nombre,nodo_aux->nombre)==0) && (strcmp(telefono,nodo_aux->telefono) == 0)){
       *lista=nodo_aux->siguiente; /* Ahora apunta al segundo de la lista */
       free(nodo_aux);} /* Libera la memoria ocupada por el nodo borrado */
    else{
      nodo_anterior = nodo_aux;
      nodo_aux = nodo_aux->siguiente;
      while ((nodo_aux->siguiente != NULL) && (!encontrado)){
        if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0)) /* Iguales */
           encontrado = 1;
        else{
           nodo_anterior = nodo_aux;
           nodo_aux = nodo_aux->siguiente;
        }
      }
      if((nodo_aux->siguiente == NULL) && (!encontrado))
       if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0)) /* Iguales */
         encontrado = 1;

      if(encontrado){
        nodo_anterior->siguiente = nodo_aux->siguiente;
        free(nodo_aux); /* Libera la memoria ocupada por el nodo borrado */
      }
    }
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ordenar(struct nodo_lista **lista){
  struct nodo_lista *nodo, *nodo_siguiente, *nodo_aux; /* Nodos para recorrer la lista */
  int fin=0; /* Cuando se recorra la lista y no haya cambio termina la ordenación */
  /* Creamos un nodo auxiliar para los intercambios de los nodos a ordenar */
  nodo_aux = (struct nodo_lista *)malloc(sizeof(struct nodo_lista));

  while(!fin){
    nodo = *lista;
    fin=1; /* Si no hay ningún cambio valdrá 1 y termina la ordenación */
    while (nodo->siguiente != NULL){
      nodo_siguiente = nodo->siguiente;
      if(strcmp(nodo->nombre, nodo_siguiente->nombre) > 0){ /* El primero mayor que el segundo */
        /* Se intercambian los datos de los nodos para que queden en orden */
        strcpy(nodo_aux->nombre,nodo_siguiente->nombre);
strcpy(nodo_siguiente->nombre,nodo->nombre);
strcpy(nodo->nombre,nodo_aux->nombre);

        strcpy(nodo_aux->telefono,nodo_siguiente->telefono);
strcpy(nodo_siguiente->telefono,nodo->telefono);
strcpy(nodo->telefono,nodo_aux->telefono);
fin=0; /* Se ha producido un cambio, hemos de realizar otra pasada por la lista */
      }
      nodo=nodo->siguiente;
    }
  }
  free(nodo_aux); /* Borramos el nodo auxiliar */
}
////////////////////////////////////////////////////////////////////////////////////////////////


[Og.]

Lo que pasa es que cuando guardas la cabecera de tu lista, solo guardas lo siguiente:

Un nombre
Un Teléfono
Un puntero

entonces cuando tu cargas el contenido habrás solo leído la dirección de memoria, y no los datos que habían en la dirección de memoria en el momento de salvado.

Saludos.