Mensajes

Hola, tengo el siguiente ejercicio que pide los datos de los clientes y quiero hacer un subprograma que me busque la deuda mayor y la muestre por pantalla. Lo he intentado, pero no me sale, me da errores.

Código (c) [Seleccionar] Expandir

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

#define LEE_CHAR(c)\
c=getchar();\
while((c=='\n') || (c==' ') || (c=='\t'))\
c=getchar();

#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 TAM_NOMBRE 100
#define TAM_DIR 100
#define NUM_CLIENTES 10
struct cliente{
char nombre[TAM_NOMBRE];
        char direccion[TAM_DIR];
        double deuda;
};
int main(){
void crear_fich();
        void deuda_mayor();
        char sel;
FILE *pf; //Puntero a fichero

        /* Abre el fichero para trabajar con él en Lectura / Escritura */
        if((pf = fopen("datos.dat", "wb+")) == NULL) {/*"rb+"*/
           /* Si no existe, ejecuta el módulo que lo cree */
   crear_fich();
   /* Una vez creado lo habre en lectura/escritura */
           if((pf = fopen("datos.dat", "rb+")) == NULL) {
perror("Fichero no accesible");
                exit(1);
   }
        }

do{
printf("MENÚ\n----\n");

printf("1). Dar de alta un cliente.\n");
                printf("2). Mostrar la deuda mayor.\n");
                printf("3). salir y eliminar.\n");
                printf("0). Salir\n\nOpción(0-2): ");

do{
LEE_CHAR(sel);
}while( (sel<'0') || (sel>'3') );

switch(sel){
case '1':{
crear_fich(pf);
    /* Una vez creado lo abre en lectura/escritura */
    if((pf = fopen("datos.dat", "rb+")) == NULL) {
perror("Fichero no accesible");
                exit(2);
    }
break;}
                                case '2':{ deuda_mayor(pf);
                                        break;}
                                case '3':{ fclose(pf); pf=NULL; remove("datos.dat"); sel= '0';
break;}
                } //switch
}while(sel!='0');

exit(0);
}//main()
////////////////////////////////////////
void crear_fich(FILE* pf) {
         struct cliente cli[NUM_CLIENTES];
         int i=0;
         char otro;

if((pf = fopen("datos.dat", "ab")) == NULL) {
perror("Al crear el fichero de datos");
                exit(2);
         }
         
         /* Lectura de los ciclistas */
         do {

cli[i].deuda = 0.0;
                printf("Nombre: "); LEE_CAD(cli[i].nombre, TAM_NOMBRE);
                printf("Dirección: "); LEE_CAD(cli[i].direccion, TAM_DIR);
                printf("Deuda: "); scanf("%lf", &cli[i].deuda);
                /*Escribe el cliente en el fichero */
                fwrite(&cli, sizeof(struct cliente), 1, pf);
printf("¿Otro? (s/n) ");
                LEE_CHAR(otro);
        }while((otro=='s') || (otro=='S'));
if(fclose(pf) == EOF){
printf("Error al cerrar el fichero, compruebe si hay información.\n");
                exit(3);
        }
} /* crear_fich()*/
//////////////////////////////////
void deuda_mayor(FILE *pf){
        struct cliente cli[NUM_CLIENTES]; 
        int i=0;
        int deuda_mayor;
        deuda_mayor=0;
        for(i=0; i<NUM_CLIENTES; i++){
            rewind(pf);
            fread(&cli,sizeof(struct cliente),1,pf);
            while(!feof(pf)){
                for(i=1; i<NUM_CLIENTES; i++){
                   if(cli[i].deuda > cli[deuda_mayor].deuda);
                      deuda_mayor=i;
                }
            }
            printf("%s %.2lf\n", cli[deuda_mayor].nombre,cli[deuda_mayor].deuda);
        }
}

Cuando le doy la opción 2 que es mostrar la deuda mayor no hace nada.

He intentado hacerlo de otra manera y si que lee caracter a caracter el fichero "datos.dat", este es el programa:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
int main()
{
  FILE  *pf;
  char letra;

  // Abro el fichero
  pf = fopen("datos.dat","rb");

  // Si ha dado fallado termino
  if ( pf == NULL )
     {
     printf("Error al abrir el fichero.");
     return 1;
     }
  else{
  letra = getc(pf);
  while ( !feof(pf) ) // Mientras no sea final de fichero
     {
     printf("%c",letra);    // Muestra el caracter leido
     letra = getc(pf);
     }

   // Cerrar fichero
  fclose(pf);
  getchar();
  return 0;
  }
}


Ahora cómo hago para decirle que cuando encuentre un salto de linea me lo sustituya por una coma porque no tengo mucha idea.

Hola, tengo un fichero binario con varios registros, lo que quiero es sustituir el salto de linea que separa a cada registro por una coma, para así a la hora de imprimirlos me saga cada registro separado por una coma.

Primero se trata de abrir el fichero binario en lectura ir leyendo caracter a caracter y en cuanto encuentra el salto de linea sustituirlo por la coma y cuando llegue al final cerrar el fichero.

Yo he empezado haciendo esto, pero me da error de lectura.

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main(){
         char nom_fich[50];
         char caracter;
         FILE *pf;

         printf("Introduzca nombre del fichero: ");
         scanf("%49s", nom_fich);

         if((pf = fopen("datos.dat", "rb")) == NULL) {
printf("Error al abrir el fichero.\n");
         }
         else{
             caracter = getc(pf);
             while(caracter != EOF){
                printf("%c", caracter);
                caracter = getc(pf);
             }
             if(feof(pf)==0){
               printf("Error de lectura.\n");
             }
             fclose(pf);
         }
         return(0);
}

Hola, tengo que crear un script en visual basic que cree un enlace a la página web www.google.com. En el programa aparecerá un menú donde elegiremos donde crear el enlace. El enlace se podrá crear en el escritorio (Desktop) o en mis documentos (My Documents). Si no se introduce ninguna de las dos opciones anteriores o es incorrecto nos dará un mensaje de error.

Es una de las preguntas que me han salido en el examen y he sacado un 4. Me gustaría que me ayudarais a resolver este ejercicio, ya que no puedo practicar en casa porque no tengo Windows.
Si me podéis decir alguna pagina donde haya ejercicios resueltos de Visual Basic Script os lo agradecería. Gracias.

El siguiente programa ordena los nombres alfabéticamente usando qsort, lo que quiero es mediante un switch darle la opción de ordenar por el nombre u ordenar por la deuda. Lo he intentado varias veces y no me sale. Este es el código:

Código (c) [Seleccionar] Expandir

/* Programa de ejemplo de gestió de memoria dinámica. El programa tomará
los registros de un fichero y reservará la memoria necesaria para poder
guardarlos en memoria y ordenarlos con el qsort(), una vez ordenados los
volverá a guardar en el fichero */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* macro para leer cadenas con caracteres blanco filtrando los return y
   blancos iniciales  */
#define lee_cad(cad,n,fin) cad[0]=getchar(); \
                           while(((int)cad[0] == 10) || ((int)cad[0] == 32)) \
                              cad[0]=getchar();\
                           n=0; \
                           while(((int)cad[n]!= 10) && (n < fin)){ \
               n++; cad[n]=getchar();} \
           cad[n]='\0';

struct registro{
   char nombre[50];
   float deuda;
};

int main(){
  FILE * df;
  struct registro cliente;
  int i,fin;
  char op;
  int num_registros;
  struct registro *punt_memoria;
  int compara();

  if((df=fopen("apuestas.dat","wb")) == NULL){
     printf("\nError al crear el fichero apuestas.dat\n");
     exit(1);
  }


  do{
     printf("Nombre del apostante: ");
     lee_cad(cliente.nombre,i,50);
     //scanf("%49s",cliente.nombre);
     printf("Deuda? ");
     scanf("%f",&cliente.deuda);
     fwrite(&cliente,sizeof(cliente),1,df);
     printf("Otro(0 --> No / 1 --> Sí) ");
     scanf("%d",&fin);
  }
  while(fin!=0);

  fclose(df);

  if((df=fopen("apuestas.dat","rb")) == NULL){
     printf("\nError al abrir el fichero apuestas.dat\n");
     exit(1);
  }
  /* Para ver cuantos registros hay en el fichero, pongo el puntero
  al final, obtengo su posición y divido por el tamaño del registro */
  fseek(df,0,SEEK_END);

  num_registros = ftell(df)/sizeof(cliente);

  /* Reservo la memoria necesaria para estos registros */
  punt_memoria = (struct registro *)calloc(num_registros, sizeof(cliente));

  /* Leo los registro del fichero y los guardo en memoria */

  rewind(df); /* Llego el descriptor de fichero al principio */
  /* Leo todos los registros y los guardo en la zona reservada de memoria */
  fread(punt_memoria,sizeof(cliente),num_registros,df);

  fclose(df);
  /* Ordeno el vector con qsort() */

  qsort(punt_memoria,num_registros,sizeof(cliente),compara);

  /* Guarda los registros ordenados en el fichero */
  if((df=fopen("apuestas.dat","wb")) == NULL){
     printf("\nError al crear el fichero apuestas.dat\n");
     exit(1);
  }
  fwrite(punt_memoria,sizeof(cliente),num_registros,df);
  fclose(df);

  /* Mostrar el contenido del fichero ordenado */
  if((df=fopen("apuestas.dat","rb")) == NULL){
     printf("\nError al abrir el fichero apuestas.dat\n");
     exit(1);
  }
  fread(punt_memoria,sizeof(cliente),num_registros,df);
  for(i=0; i < num_registros; i++)
    printf("%s  %.1f\n",(punt_memoria+i)->nombre, (punt_memoria+i)->deuda);
  fclose(df);
  free(punt_memoria);
} /* main() */

/* La función compara usa strcmp para ordenar alfabéticamente
   el fichero */

int compara(struct registro *r1, struct registro *r2){
    return(strcmp(r1->nombre, r2->nombre));
}

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 */
}
////////////////////////////////////////////////////////////////////////////////////////////////


Hola, tengo que hacer un script que pida por teclado un carácter y determine si es una vocal, consonante, número o signo de puntuación. ¿Podéis echarme una mano?, ando muy perdida con esto de Visual Basic y el jueves tengo examen. Gracias.

Hola, el siguiente script en Visual Basic ordena tres números tomados de teclado y quería saber si está bien:

Código (vb) [Seleccionar] Expandir

Option Explicit
Dim a, b, c
var = InputBox("Introduce tre números:")
MsgBox(a, b, c)
If (( a > b) && (a > c)) Then
    If (b > c)
     MsgBox(c, b, a)
    Else
         MsgBox(b, c, a)
End If
If (( b > a) && (b > c)) Then
      If (a > c)
         MsgBox(c, a, b)
      Else
           MsgBox(a, c, b)
End If
If (( c > a) && ( c > b)) Then
     If ( a > b)
        MsgBox(b, a, c)
     Else
          MsgBox(a, b, c)
End If

Hola, tengo que hacer un script en visual basic que me cuente cuantas veces aparece una subcadena dentro de una cadena. No me aclaro Ej: estrella La letra e aparece dos veces
Debo introducir la cadena de teclado usando InputBox.

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