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:
#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);
}
}
}
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,
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.
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.
/* 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 */
}
////////////////////////////////////////////////////////////////////////////////////////////////
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.