elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: AIO elhacker.NET 2021 Compilación herramientas análisis y desinfección malware


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  insertar un nodo después de otro		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: insertar un nodo después de otro  (Leído 6,552 veces)
minette1988

Desconectado Desconectado

Mensajes: 53


Ver Perfil
insertar un nodo después de otro
« en: 16 Mayo 2010, 14:22 pm »
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
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #define LEE_CAD(c,n) { int i=0; \
  6.                      c[i]=getchar();\
  7. 		     while((c[i]=='\n') || (c[i]=='\t')) c[i]=getchar();\
  8. 		     while ((c[i]!='\n') && (i < (n-1))){ \
  9. 		        i++;\
  10. 			c[i]=getchar(); }\
  11. 		     c[i]='\0'; }
  12.  
  13. #define T_NOM 101
  14. #define T_EDAD 3
  15.  
  16.  
  17. struct persona {
  18. 	char nom[100];
  19.         char edad[3];
  20. 	struct persona *siguiente; 
  21. };
  22.  
  23. int main(){
  24.          struct persona *lista=NULL;
  25.          struct persona *nodo;
  26.  
  27.          int op;
  28.          void alta_inicio();
  29.          void alta_final();
  30.          void alta_despues_de();
  31.          void recorrer_lista();
  32.          void borrar_nodo();
  33.          struct persona * buscar_nodo();
  34.  
  35.          do{
  36.             do{
  37.                printf("Elija una opción:\n"); 
  38.                printf("1--> Añadir al principio.\n");
  39.                printf("2--> Añadir al final.\n");
  40.                printf("3--> Recorrer la lista.\n");
  41.                printf("4--> Buscar nodo.\n");
  42.                printf("5--> Eliminar nodo.\n");
  43.                printf("6--> Añadir despues de...\n");
  44.                printf("7--> Salir.\n");
  45.                scanf("%d",&op);
  46.             }while((op < 1) || (op > 7));
  47.          if(op != 4)   
  48.             switch(op){
  49.                 case 1: { alta_inicio(&lista);break;}
  50.                 case 2: { alta_final(&lista);break;}
  51.                 case 3: { recorrer_lista(&lista);break;}
  52.                 case 4: { nodo=buscar_nodo(&lista);
  53.                           printf("\n%s\n",nodo->nom);break;}
  54.                 case 5: { borrar_nodo(&lista);break;}
  55.                 case 6: { alta_despues_de(&lista);break;} 
  56.             }
  57.          }while(op != 7);
  58.          exit(0);
  59. }
  60. ////////////////////////////////////////////////////////////////////////////
  61. void alta_inicio(struct persona **lista){
  62.          struct persona *nuevo_nodo;
  63.          nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));
  64.          if(nuevo_nodo != NULL){
  65.             nuevo_nodo->siguiente = *lista;
  66.             *lista = nuevo_nodo;
  67.             printf("Nombre: ");
  68.             LEE_CAD(nuevo_nodo->nom,T_NOM);
  69.             printf("Edad: ");
  70.             LEE_CAD(nuevo_nodo->edad,T_EDAD); 
  71.          }
  72. }             
  73. ////////////////////////////////////////////////////////////////////////////////
  74. void recorrer_lista(struct persona **lista){
  75.           struct persona *nodo_aux;
  76.           nodo_aux = *lista;
  77.           while(nodo_aux != NULL){
  78.                printf("%s\n",nodo_aux->nom);
  79.                printf("%s\n",nodo_aux->edad);
  80.                nodo_aux = nodo_aux->siguiente;
  81.           }
  82. }
  83. //////////////////////////////////////////////////////////////////////////////
  84. void alta_final(struct persona **lista){
  85.           struct persona *nuevo_nodo;
  86.           struct persona *nodo_aux;
  87.  
  88.           nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));
  89.           if(nuevo_nodo != NULL){
  90.              nodo_aux = *lista;
  91.              while(nodo_aux->siguiente != NULL)
  92.                 nodo_aux = nodo_aux->siguiente;
  93.                 nodo_aux->siguiente=nuevo_nodo;
  94.                 nuevo_nodo->siguiente=NULL;
  95.                 printf("Nombre del nuevo elemento: ");
  96.                 LEE_CAD(nuevo_nodo->nom,T_NOM);
  97.                 printf("Edad del nuevo elemento: ");
  98.                 LEE_CAD(nuevo_nodo->edad,T_EDAD);
  99.           }
  100.           else
  101.                printf("Error al tomar memoria del nuevo nodo.\n");
  102. }
  103. /////////////////////////////////////////////////////////////////////////////////
  104. struct persona *buscar_nodo(struct persona **lista){
  105.           struct persona *nodo_aux, *resultado;
  106.           char nom[100];
  107.           char edad[3];
  108.           int encontrado = 0;
  109.  
  110.           printf("Nombre a buscar: ");
  111.           scanf("%99s",nom);
  112.  
  113.           nodo_aux = *lista;
  114.           while((nodo_aux->siguiente != NULL) && (!encontrado)){
  115.                 if(strcmp(nom,nodo_aux->nom) == 0)
  116.                   encontrado = 1;
  117.                 else
  118.                     nodo_aux = nodo_aux->siguiente;
  119.           }
  120.           if((nodo_aux->siguiente == NULL) && (!encontrado))
  121.               if(strcmp(nom,nodo_aux->nom) == 0)
  122.                  encontrado = 1;
  123.           if(encontrado)
  124.             resultado = NULL;
  125.           return(resultado);
  126.  
  127.           printf("Edad a buscar: ");
  128.           scanf("%2s",edad);
  129.  
  130.           nodo_aux = *lista;
  131.           while((nodo_aux->siguiente != NULL) && (!encontrado)){
  132.                 if(strcmp(edad,nodo_aux->edad) == 0)
  133.                   encontrado = 1;
  134.                 else
  135.                     nodo_aux = nodo_aux->siguiente;
  136.           }
  137.           if((nodo_aux->siguiente == NULL) && (!encontrado))
  138.               if(strcmp(edad,nodo_aux->edad) == 0)
  139.                  encontrado = 1;
  140.           if(encontrado)
  141.             resultado = NULL;
  142.           return(resultado); 
  143. }
  144. ////////////////////////////////////////////////////////////////////////////////
  145. void borrar_nodo(struct persona **lista){
  146.           struct persona *nodo_aux, *nodo_anterior;
  147.           char nom[100];
  148.           char edad[3];
  149.           int encontrado = 0;
  150.  
  151.           printf("Nombre a borrar: ");
  152.           scanf("%99s",nom);
  153.           nodo_aux = *lista;
  154.  
  155.           if(strcmp(nom,nodo_aux->nom) == 0){
  156.             *lista=nodo_aux->siguiente;
  157.             free(nodo_aux);}
  158.           else{
  159.                nodo_anterior = nodo_aux;
  160.                nodo_aux = nodo_aux->siguiente;
  161.                while((nodo_aux->siguiente != NULL) && (!encontrado)){
  162.                    if(strcmp(nom,nodo_aux->nom) == 0)          
  163.                      encontrado = 1;
  164.                    else{
  165.                       nodo_anterior = nodo_aux;
  166.                       nodo_aux = nodo_aux->siguiente;
  167.                    }
  168.                }  
  169.                if((nodo_aux->siguiente == NULL) && (!encontrado)) 
  170.                   if(strcmp(nom,nodo_aux->nom) == 0)
  171.                      encontrado = 1;
  172.                if(encontrado){
  173.                   nodo_anterior->siguiente = nodo_aux->siguiente;
  174.                   free(nodo_aux);
  175.                }
  176.           }
  177.           printf("Edad a borrar: ");
  178.           scanf("%2s",edad);
  179.           nodo_aux = *lista;
  180.  
  181.           if(strcmp(edad,nodo_aux->edad) == 0){
  182.             *lista=nodo_aux->siguiente;
  183.             free(nodo_aux);}
  184.           else{
  185.                nodo_anterior = nodo_aux;
  186.                nodo_aux = nodo_aux->siguiente;
  187.                while((nodo_aux->siguiente != NULL) && (!encontrado)){
  188.                    if(strcmp(edad,nodo_aux->edad) == 0)          
  189.                      encontrado = 1;
  190.                    else{
  191.                       nodo_anterior = nodo_aux;
  192.                       nodo_aux = nodo_aux->siguiente;
  193.                    }
  194.                }  
  195.                if((nodo_aux->siguiente == NULL) && (!encontrado)) 
  196.                   if(strcmp(edad,nodo_aux->edad) == 0)
  197.                      encontrado = 1;
  198.                if(encontrado){
  199.                   nodo_anterior->siguiente = nodo_aux->siguiente;
  200.                   free(nodo_aux);
  201.                }
  202.           }
  203. }
  204. ///////////////////////////////////////////////////////////////////////////////
  205. void alta_despues_de(struct persona **lista){
  206.            struct persona *nuevo_nodo;
  207.            struct persona *nodo_aux;
  208.            char nom[100];
  209.            char edad[3]; 
  210.            int encontrado = 0;
  211.  
  212.            printf("Nombre a buscar para insertar después de el: ");
  213.            scanf("%99s",nom);
  214.  
  215.            nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));
  216.  
  217.            if(nuevo_nodo != NULL){
  218.              nodo_aux = *lista;
  219.              while((nodo_aux->siguiente != NULL) && (!encontrado)){ 
  220.                   if(strcmp(nom,nodo_aux->nom) == 0)
  221.                      encontrado = 1;
  222.                   else{
  223.                        nodo_aux = nodo_aux->siguiente;
  224.                   }
  225.              }
  226.              if((nodo_aux->siguiente == NULL) && (!encontrado))
  227.                 if(strcmp(nom,nodo_aux->nom) == 0)
  228.                   encontrado = 1;
  229.  
  230.              if(encontrado){
  231.                 nuevo_nodo->siguiente=nodo_aux->siguiente;
  232.                 nodo_aux->siguiente=nuevo_nodo;
  233.                 printf("Nombre del nuevo elemento: ");
  234.                 scanf("%99s",nuevo_nodo->nom);
  235.              }
  236.              else{
  237.                   printf("Elemento no encontrado.\n");
  238.                   free(nuevo_nodo);
  239.              }
  240.            }
  241.            printf("Edad a buscar para insertar después de el: ");
  242.            scanf("%2s",edad);
  243.  
  244.            nuevo_nodo=(struct persona *)malloc(sizeof(struct persona));
  245.  
  246.            if(nuevo_nodo != NULL){
  247.              nodo_aux = *lista;
  248.              while((nodo_aux->siguiente != NULL) && (!encontrado)){ 
  249.                   if(strcmp(edad,nodo_aux->edad) == 0)
  250.                      encontrado = 1;
  251.                   else{
  252.                        nodo_aux = nodo_aux->siguiente;
  253.                   }
  254.              }
  255.              if((nodo_aux->siguiente == NULL) && (!encontrado))
  256.                 if(strcmp(edad,nodo_aux->edad) == 0)
  257.                   encontrado = 1;
  258.  
  259.              if(encontrado){
  260.                 nuevo_nodo->siguiente=nodo_aux->siguiente;
  261.                 nodo_aux->siguiente=nuevo_nodo;
  262.                 printf("Edad del nuevo elemento: ");
  263.                 scanf("%2s",nuevo_nodo->edad);
  264.              }
  265.              else{
  266.                   printf("Elemento no encontrado.\n");
  267.                   free(nuevo_nodo);
  268.              }
  269.            }
  270. }
En línea
Og.


Desconectado Desconectado

Mensajes: 822


Aprendiendo de la vida


Ver Perfil
Re: insertar un nodo después de otro
« Respuesta #1 en: 16 Mayo 2010, 21:25 pm »
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
  1. int a = 2;
  2. presona *nuevo, *prev = &lista, *ll = &lista;
  3. ll = ll->siguiete;
  4. cin >> nuevo->nom >> nuevo->edad;
  5. while(a--)
  6. {
  7.     prev = ll;
  8.     ll = ll->siguiente;
  9. }
  10. prev->siguente = nuevo;
  11. nuevo->siguiente = ll;

Ojala te sirva de algo.
En línea
|-
minette1988

Desconectado Desconectado

Mensajes: 53


Ver Perfil
Re: insertar un nodo después de otro
« Respuesta #2 en: 25 Mayo 2010, 12:12 pm »
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
  1. /* Implementación de una lista enlazada */
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5.  
  6. #define LEE_CAD(c,n) { int i=0; \
  7.                      c[i]=getchar();\
  8. 		     while((c[i]=='\n') || (c[i]=='\t')) c[i]=getchar();\
  9. 		     while ((c[i]!='\n') && (i < (n-1))){ \
  10. 		        i++;\
  11. 			c[i]=getchar(); }\
  12. 		     c[i]='\0'; }
  13.  
  14. #define T_NOM 101
  15. #define T_TEL 10
  16.  
  17.  
  18. struct nodo_lista{
  19.    char nombre[T_NOM];
  20.    char telefono[T_TEL];
  21.    struct nodo_lista * siguiente; /*Puntero al siguiente elemento de la lista*/
  22. };
  23.  
  24. int main(){
  25.   struct nodo_lista *lista = NULL; /* Puntero al inicio de la lista, vacía */
  26.   struct nodo_lista *nodo;
  27.  
  28.   int op; /* Variable para tomar la opción del menú del programa */
  29.  
  30.   void alta_inicio();
  31.   void alta_final();
  32.   void alta_despues_de();
  33.   void mostrar_lista();
  34.   void ordenar();
  35.   void borrar_nodo();
  36.  
  37.  
  38.   struct nodo_lista * buscar_nodo_nombre(); /* Devuelve un puntero al nodo buscado */
  39.   struct nodo_lista * buscar_nodo_telefono();
  40.  
  41.  
  42.   do{
  43.     do{
  44.        printf("1--> Añadir al Principio.\n");
  45.        printf("2--> Añadir al Final.\n");
  46.        printf("3--> Añadir después de.\n");
  47.        printf("4--> mostrar el total de la lista.\n");
  48.        printf("5--> Buscar (nodo)nombre para saber el telefono.\n");
  49.        printf("6--> Buscar (nodo)telefono para saber el nombre.\n");
  50.        printf("7--> Eliminar nodo.\n");
  51.        printf("8--> ordenar filas alfabeticamente\n");
  52.        printf("9--> Salir.\n");
  53.        scanf("%d",&op);
  54.      }while((op < 1) || (op > 9));
  55.      if( op != 9)
  56.        switch(op){
  57.           case 1: { alta_inicio(&lista); break;}
  58.           case 2: { alta_final(&lista); break;}
  59.           case 3: { alta_despues_de(&lista);break;} 
  60.           case 4: { mostrar_lista(&lista); break;}
  61.           case 5: { nodo = buscar_nodo_nombre(&lista);
  62.                     printf("\n%s\n",nodo->telefono);
  63.                     break;}
  64.           case 6: { nodo = buscar_nodo_telefono(&lista);
  65.                     printf("\n%s\n",nodo->nombre);
  66.                     break;}
  67.           case 7: { borrar_nodo(&lista); break;}
  68. 	  case 8: { ordenar(&lista);break;}
  69.        }
  70.   }while(op != 9);
  71. }
  72. ////////////////////////////////////////////////////////////////////
  73. void alta_inicio(struct nodo_lista **lista){    
  74.   struct nodo_lista *nuevo_nodo; /* Variable usada para crear nuevos nodos 
  75.                                     que serán añadidos a la lista */        
  76.  
  77.   /* Creamos un nodo con malloc()*/     
  78.   nuevo_nodo=(struct nodo_lista *)malloc(sizeof(struct nodo_lista)); 
  79.   if (nuevo_nodo != NULL){
  80.  
  81.     /* Lo ponemos la principio */
  82.     nuevo_nodo->siguiente = *lista; /* Apunta al elemento que pasará a ser el 
  83.                                     segundo de la lista */
  84.     *lista = nuevo_nodo; /* El inicio de la lista apunta al nuevo nodo */
  85.     /* Tomamos el dato del nuevo nodo */
  86.  
  87.     printf("Nombre: ");
  88.     LEE_CAD(nuevo_nodo->nombre,T_NOM);   
  89.     printf("Telefono: ");
  90.     LEE_CAD(nuevo_nodo->telefono,T_TEL);   
  91.   }
  92.   else
  93.     printf("Error al tomar memoria para el nuevo nodo.\n");
  94. }
  95. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  96. void mostrar_lista(struct nodo_lista **lista){
  97.   struct nodo_lista *nodo_aux; /* Nodo auxiliar para recorrer la lista */
  98.  
  99.   nodo_aux = *lista;
  100.   while ( nodo_aux != NULL){
  101.      printf("%s  %s\n",nodo_aux->nombre,nodo_aux->telefono);
  102.      nodo_aux = nodo_aux->siguiente; /* El nodo auxiliar ahora apunta al
  103.                                         elemento siguiente */
  104.   }
  105. }
  106. /////////////////////////////////////////////////////////////////////////////////////////////
  107. void alta_final(struct nodo_lista **lista){
  108.   struct nodo_lista *nuevo_nodo; /* Variable usada para crear nuevos nodos
  109.                                     que serán añadidos a la lista */
  110.   struct nodo_lista *nodo_aux; /* Nodo auxiliar para recorrer la lista */
  111.  
  112.   /* Creamos un nodo con malloc()*/
  113.   nuevo_nodo=(struct nodo_lista *)malloc(sizeof(struct nodo_lista));
  114.   if (nuevo_nodo != NULL){
  115.     nodo_aux = *lista;
  116.     while (nodo_aux->siguiente != NULL) /* Vamos al final de la lista */
  117.       nodo_aux = nodo_aux->siguiente; /* El nodo auxiliar ahora apunta al
  118.                                         elemento siguiente */
  119.     nodo_aux->siguiente=nuevo_nodo; /* El que era el último ahora apunta al
  120.                                        nodo nuevo que será el último */
  121.     nuevo_nodo->siguiente=NULL;
  122.     printf("Nombre del nuevo elemento: ");
  123.     LEE_CAD(nuevo_nodo->nombre,T_NOM);
  124.     printf("Telefono del nuevo elemento: ");
  125.     LEE_CAD(nuevo_nodo->telefono,T_TEL);
  126.   }
  127.   else
  128.     printf("Error al tomar memoria para el nuevo nodo.\n");
  129. }
  130. /////////////////////////////////////////////////////////////////////////////////////////////
  131. void alta_despues_de(struct nodo_lista **lista){
  132.    struct nodo_lista *nuevo_nodo;
  133.    struct nodo_lista *nodo_aux;
  134.  
  135.    char nombre[T_NOM];
  136.    char telefono[T_TEL];
  137.    int encontrado = 0;
  138.  
  139.    printf("Nombre a buscar para insertar después de él: ");
  140.    LEE_CAD(nombre,T_NOM);
  141.    printf("Telefono a buscar para insertar después de él: ");
  142.    LEE_CAD(telefono,T_TEL);
  143.    nuevo_nodo=(struct nodo_lista *)malloc(sizeof(struct nodo_lista));
  144.  
  145.    if(nuevo_nodo != NULL){
  146.       nodo_aux = *lista;
  147.       while((nodo_aux->siguiente != NULL) && (!encontrado)){
  148.         if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0))
  149.           encontrado = 1;
  150.         else{
  151.              nodo_aux = nodo_aux->siguiente;
  152.         }
  153.       }
  154.    }
  155.    if((nodo_aux->siguiente == NULL) && (!encontrado))
  156.        if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0))
  157.           encontrado = 1;
  158.  
  159.        if(encontrado){
  160.           nuevo_nodo->siguiente=nodo_aux->siguiente;
  161.           nodo_aux->siguiente=nuevo_nodo;
  162.           printf("Nombre del nuevo elemento: ");
  163.           LEE_CAD(nuevo_nodo->nombre,T_NOM);
  164.           printf("Telefono del nuevo elemento: ");
  165.           LEE_CAD(nuevo_nodo->telefono,T_TEL);
  166.       }
  167.       else{
  168.            printf("Elemento no encontrado.\n");
  169.            free(nuevo_nodo);
  170.       }
  171. }
  172. //////////////////////////////////////////////////////////////////////////////////////////////
  173. struct nodo_lista * buscar_nodo_nombre(struct nodo_lista **lista){
  174.     struct nodo_lista *nodo_aux, *resultado; /* Nodo auxiliar para recorrer la lista */
  175.     char nombre[T_NOM]; /* Nombre a buscar en la lista */
  176.     int encontrado = 0; /* Si encuentra el nodo se pone a 1 */
  177.     printf("Nombre a buscar: ");
  178.     LEE_CAD(nombre,T_NOM);
  179.  
  180.     nodo_aux = *lista;
  181.     /* Mientras no se llegue al final de la lista o se encuentre el nombre
  182.        avanza en la lista */
  183.     while((nodo_aux->siguiente != NULL) && (!encontrado)){
  184.       if(strcmp(nombre,nodo_aux->nombre) == 0) /* Iguales */
  185.          encontrado = 1;
  186.       else
  187.          nodo_aux = nodo_aux->siguiente;
  188.     }
  189.     /* Comprueba si el último de la lista es el elemento buscado */
  190.     if((nodo_aux->siguiente == NULL) && (!encontrado))
  191.        if(strcmp(nombre,nodo_aux->nombre) == 0) /* Iguales */
  192.          encontrado = 1;
  193.  
  194.     if(encontrado)
  195.       resultado = nodo_aux;
  196.     else /* Si no lo encuentra devuelve NULL */
  197.       resultado = NULL;
  198.     return(resultado);
  199. }
  200. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  201. struct nodo_lista * buscar_nodo_telefono(struct nodo_lista **lista){
  202.     struct nodo_lista *nodo_aux, *resultado; /* Nodo auxiliar para recorrer la lista */
  203.     char telefono[T_TEL]; /* Nombre a buscar en la lista */
  204.     int encontrado = 0; /* Si encuentra el nodo se pone a 1 */
  205.     printf("Telefono a buscar: ");
  206.     LEE_CAD(telefono,T_TEL);
  207.  
  208.     nodo_aux = *lista;
  209.     /* Mientras no se llegue al final de la lista o se encuentre el nombre
  210.        avanza en la lista */
  211.     while((nodo_aux->siguiente != NULL) && (!encontrado)){
  212.       if(strcmp(telefono,nodo_aux->telefono) == 0) /* Iguales */
  213.          encontrado = 1;
  214.       else
  215.          nodo_aux = nodo_aux->siguiente;
  216.     }
  217.     /* Comprueba si el último de la lista es el elemento buscado */
  218.     if((nodo_aux->siguiente == NULL) && (!encontrado))
  219.        if(strcmp(telefono,nodo_aux->telefono) == 0) /* Iguales */
  220.          encontrado = 1;
  221.  
  222.     if(encontrado)
  223.       resultado = nodo_aux;
  224.     else /* Si no lo encuentra devuelve NULL */
  225.       resultado = NULL;
  226.     return(resultado);
  227. }
  228. ////////////////////////////////////////////////////////////////////////////////////////////////////////////
  229. void borrar_nodo(struct nodo_lista **lista){
  230.     /* Para borrar un nodo, tendremos que guardar un puntero al nodo anterior
  231.        del que nos encontramos, ya que este puntero pasará a apuntar al nodo
  232.        apuntado por el que vamos a borrar */
  233.     struct nodo_lista *nodo_aux, *nodo_anterior;
  234.     char nombre[T_NOM];
  235.     char telefono[T_TEL];
  236.     int encontrado = 0;
  237.  
  238.     printf("Nombre a borrar: ");
  239.     LEE_CAD(nombre,T_NOM);
  240.     printf("Telefono a borrar: ");
  241.     LEE_CAD(telefono,T_TEL);
  242.     nodo_aux = *lista;
  243.     /* Comprueba si el elemento a borrar es el primero de la lista */
  244.     if((strcmp(nombre,nodo_aux->nombre)==0) && (strcmp(telefono,nodo_aux->telefono) == 0)){
  245.        *lista=nodo_aux->siguiente; /* Ahora apunta al segundo de la lista */
  246.        free(nodo_aux);} /* Libera la memoria ocupada por el nodo borrado */
  247.     else{
  248.       nodo_anterior = nodo_aux;
  249.       nodo_aux = nodo_aux->siguiente;
  250.       while ((nodo_aux->siguiente != NULL) && (!encontrado)){
  251.         if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0)) /* Iguales */
  252.            encontrado = 1;
  253.         else{
  254.            nodo_anterior = nodo_aux;
  255.            nodo_aux = nodo_aux->siguiente;
  256.         }
  257.       }
  258.       if((nodo_aux->siguiente == NULL) && (!encontrado))
  259.        if((strcmp(nombre,nodo_aux->nombre) == 0) && (strcmp(telefono,nodo_aux->telefono) == 0)) /* Iguales */
  260.          encontrado = 1;
  261.  
  262.       if(encontrado){
  263.         nodo_anterior->siguiente = nodo_aux->siguiente;
  264.         free(nodo_aux); /* Libera la memoria ocupada por el nodo borrado */
  265.       }
  266.     }
  267. }
  268. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  269. void ordenar(struct nodo_lista **lista){
  270.   struct nodo_lista *nodo, *nodo_siguiente, *nodo_aux; /* Nodos para recorrer la lista */
  271.   int fin=0; /* Cuando se recorra la lista y no haya cambio termina la ordenación */
  272.   /* Creamos un nodo auxiliar para los intercambios de los nodos a ordenar */
  273.   nodo_aux = (struct nodo_lista *)malloc(sizeof(struct nodo_lista));
  274.  
  275.   while(!fin){
  276.     nodo = *lista;
  277.     fin=1; /* Si no hay ningún cambio valdrá 1 y termina la ordenación */
  278.     while (nodo->siguiente != NULL){
  279.       nodo_siguiente = nodo->siguiente;
  280.       if(strcmp(nodo->nombre, nodo_siguiente->nombre) > 0){ /* El primero mayor que el segundo */
  281.         /* Se intercambian los datos de los nodos para que queden en orden */
  282.         strcpy(nodo_aux->nombre,nodo_siguiente->nombre);
  283. 	strcpy(nodo_siguiente->nombre,nodo->nombre);
  284. 	strcpy(nodo->nombre,nodo_aux->nombre);
  285.  
  286.         strcpy(nodo_aux->telefono,nodo_siguiente->telefono);
  287. 	strcpy(nodo_siguiente->telefono,nodo->telefono);
  288. 	strcpy(nodo->telefono,nodo_aux->telefono);
  289. 	fin=0; /* Se ha producido un cambio, hemos de realizar otra pasada por la lista */
  290.       }
  291.       nodo=nodo->siguiente;
  292.     }
  293.   }
  294.   free(nodo_aux); /* Borramos el nodo auxiliar */
  295. }
  296. ////////////////////////////////////////////////////////////////////////////////////////////////
  297.  
En línea
Og.


Desconectado Desconectado

Mensajes: 822


Aprendiendo de la vida


Ver Perfil
Re: insertar un nodo después de otro
« Respuesta #3 en: 25 Mayo 2010, 15:20 pm »
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.
En línea
|-
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda con funcion insertar nodo en lista!!!
Programación C/C++ 		mathias_vg 5 2,740 Último mensaje 10 Octubre 2015, 22:24 pm
por ivancea96
Insertar nodo en Arbol Generico
Software 		EASoft 0 1,763 Último mensaje 21 Agosto 2019, 15:03 pm
por EASoft
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines