Como viene siendo habitual, aquí dejo mi examen de listas enlazadas espero que sea de ayuda.

Descargar | Código Fuente Del Examen

Los apartados que se pedían en el examen eran:

Crear la lista películas
Consiste en crear una lista enlazada dando de alta las películas del videoclub. Esta lista está ordenada por cod.

Actualizar la lista enlazada películas con la información de la tabla tdía.
Este proceso guarda en una tabla con las operaciones que se van a realizar en la lista, es decir las actualizaciones que se van a realizar y pueden ser:
Película NUEVA, valor del campo operación: Está operación significa dar de alta la película en la lista enlazada, en el lugar correspondiente, es decir, manteniendo el orden. Si ya existe la película visualizar los mensajes de error oportunos
Película DEVUELTA, valor del campo operación 2. Esta operación consiste en incrementar el campo existencias. Sacar mensajes de error oportunos.
Película BAJA, valor del campo operación 3. Esta operación consiste en borrar la película de la lista enlazada. Sacar los mensajes oportunos en caso de error.

Visualizar lista.

PLAIN TEXT
C:
  1. #include <stdio .h>
  2. #include <stdlib .h>
  3. #include <string .h>
  4. #include <conio .h>
  5. #define MAX 25
  6. #define NUEVA 1
  7. #define DEVUELTA 2
  8. #define BAJA 3
  9. struct tdia
  10. {
  11.     char codigo[20];
  12.     int operacion;
  13. };
  14. typedef struct tpeliculas
  15. {
  16.     char cod[20];
  17.     int existencias;
  18.     struct tpeliculas *sig;
  19. }nodo;
  20.  
  21. int menu();
  22. nodo * nuevo_nodo();
  23. void cargar_lista(nodo ** inicio);
  24. char cargar_tabla(struct tdia *tabla);
  25. void actualizar_lista(struct tdia tabla[MAX], nodo **inicio, int total);
  26. void ver_lista(nodo * inicio);
  27. void borrar_lista(nodo ** inicio);
  28.  
  29. void main()
  30. {
  31.     struct tdia tabla[MAX];
  32.     nodo *inicio=NULL;
  33.     int opcion, i;
  34.     char resp='s';
  35.     do{
  36.     opcion=menu();
  37.     switch(opcion)
  38.         {
  39.         case 1:
  40.             clrscr();
  41.             cargar_lista(&inicio);
  42.             break;
  43.         case 2:
  44.             clrscr();
  45.             resp='s';
  46.             printf(":::OPERACIONES:::\n");
  47.             printf("Nueva Pelicula [1]\n");
  48.             printf("Pelicula Devuelta [2]\n");
  49.             printf("Borrar Pelicula [3]\n");
  50.             for(i=0; i<max && resp!='n'; i++)
  51.             {
  52.                 printf("\nElemento  %d de la tabla:", i+1);
  53.                 resp=cargar_tabla(&tabla[i]);
  54.             }
  55.             break;
  56.         case 3:
  57.             clrscr();
  58.             actualizar_lista(tabla, &inicio, i);
  59.             printf("\n\nPresione una tecla para continuar");
  60.             getche();
  61.             break;
  62.         case 4:
  63.             clrscr();
  64.             ver_lista(inicio);
  65.             printf("\n\nPresione una tecla para continuar");
  66.             getche();
  67.             break;
  68.         case 5:
  69.             clrscr();
  70.             opcion=7;
  71.             borrar_lista(&inicio);
  72.             break;
  73.         default:
  74.             menu();
  75.         }
  76.     }while(opcion!=7);
  77. }
  78.  
  79. nodo * nuevo_nodo()
  80. {
  81.     //reservamos memoria para un elemento de la lista
  82.     nodo *p;
  83.     p=(nodo *)malloc(sizeof(nodo));
  84.     if (!p)
  85.     {
  86.         perror("Insuficiente  memoria");
  87.         exit(1);
  88.     }
  89.     //la direccion del siguiente elemento la iniciamos aqui a NULL
  90.     //hasta que coja un valor.
  91.     p->sig=NULL;
  92.     return(p);
  93. }
  94.  
  95. void cargar_lista(nodo ** inicio)
  96. {
  97.     char resp, codigo[20];
  98.     int existencias;
  99.     nodo *actual, *anterior, *nuevo_elem;
  100.     do
  101.     {
  102.         printf("\n:.:NUEVA PELICULA:.:\n");
  103.         printf("\n\tCodigo: ");
  104.         gets(codigo); fflush(stdin);
  105.         printf("\n\tExistencias: ");
  106.         scanf("%d", &existencias); fflush(stdin);
  107.         anterior=actual=*inicio;
  108.         while(actual!=NULL && strcmp(actual->cod,codigo)>0)
  109.         {
  110.             //busca posicion para nuevo elemento
  111.             anterior=actual;
  112.             actual=actual->sig;
  113.         }
  114.         //asignamos memoria para un nuevo nodo
  115.         nuevo_elem=nuevo_nodo();
  116.         strcpy(nuevo_elem->cod, codigo);
  117.         nuevo_elem->existencias=existencias;
  118.         //enlazamos el elemento en la lista entre el elemento anterior y el del
  119.         //recorrido del while actual
  120.         if(anterior==NULL || anterior == actual)
  121.         {
  122.             //Para insertar en el incio de la lista
  123.             nuevo_elem->sig=anterior;
  124.             *inicio=nuevo_elem;//tenemos que actualizar el comienzo de la lista
  125.         }
  126.         else
  127.         {
  128.             //en el caso de elementos intermedios y el final
  129.             nuevo_elem->sig=actual;
  130.             anterior->sig=nuevo_elem;
  131.         }
  132.         printf("\n¿Desea introducir otro producto? ");
  133.         scanf("%c", &resp); fflush(stdin);
  134.     }while(resp!='n');
  135. }
  136.  
  137. char cargar_tabla(struct tdia *tabla)
  138. {
  139.     char resp;
  140.     printf("\n\tCodigo: ");
  141.     gets(tabla->codigo); fflush(stdin);
  142.     printf("\n\tOperacion: ");
  143.     scanf("%d", &(tabla->operacion)); fflush(stdin); -
  144.     printf("\n¿Desea introducir en la tabla otra pelicula? ");
  145.     scanf("%c", &resp); fflush(stdin);
  146.     return(resp);
  147. }
  148.  
  149. void actualizar_lista(struct tdia tabla[MAX], nodo **inicio, int total)
  150. {
  151.     nodo *p,*ante, *nuevo_elem;
  152.     ante=p=*inicio;
  153.  
  154.     int j, existencias, sw=0, error=0;
  155.     char codigo[20];
  156.     ver_lista(*inicio);
  157.     printf("\n");
  158.     printf("\n\n::.::ACTUALIZANDO STOCK DEL VIDEO-CLUB::.::\n");
  159.     for(j=0;j<total ;j++)
  160.     {
  161.         error=0;
  162.         if(tabla[j].operacion==NUEVA)
  163.         {
  164.                 p=*inicio;
  165.                 while(p!=NULL)
  166.                 {
  167.                     if (strcmp(p->cod, tabla[j].codigo)==0)
  168.                     {
  169.                         error=1;//quiere decir que existe el codigo y mostraremos un
  170.                         //mensaje de error
  171.                     }
  172.                     p=p->sig;
  173.                 }
  174.                 if(error==0)
  175.                 {
  176.                     //se va a introducir el elemento respetando el orden
  177.                     ante=p=*inicio;
  178.                     while(p!=NULL && strcmp(p->cod, tabla[j].codigo)>0)
  179.                     {
  180.                         //busca posicion para nuevo elemento
  181.                         ante=p;
  182.                         p=p->sig;
  183.                     }
  184.                     nuevo_elem=nuevo_nodo();
  185.                     strcpy(nuevo_elem->cod, tabla[j].codigo);
  186.                     nuevo_elem->existencias=10;
  187.                     //enlazamos el elemento en la lista
  188.                     if(ante==NULL || ante==p)
  189.                     {
  190.                         //inserta al principio al inicio
  191.                         nuevo_elem->sig=ante;
  192.                         *inicio=nuevo_elem;
  193.                     }
  194.                     else
  195.                     {
  196.                         //caso de elementos intermedios y final
  197.                         nuevo_elem->sig=p;
  198.                         ante->sig=nuevo_elem;
  199.                     }
  200.                 }
  201.                 else
  202.                     printf("\nERROR NUEVA PELICULA: LA PELICULA %s YA EXISTE", tabla[j].codigo);
  203.         }
  204.         error=0;
  205.         if(tabla[j].operacion==DEVUELTA)
  206.         {
  207.             p=*inicio;
  208.             while(p!=NULL)
  209.             {
  210.                 if (strcmp(p->cod, tabla[j].codigo)==0)
  211.                 {
  212.                     error=1;//quiere decir que existe el codigo y mostraremos un
  213.                     //mensaje de error
  214.                 }
  215.                 p=p->sig;
  216.             }
  217.             if(error==1)
  218.             {
  219.                 p=*inicio;
  220.                 while(p!=NULL)
  221.                 {
  222.                     //devolvemos una peli
  223.                     if(strcmp(p->cod, tabla[j].codigo)==0)
  224.                         p->existencias+=1;
  225.                     p=p->sig;
  226.                 }
  227.             }
  228.          else
  229.                     printf("\nERROR PELICULA DEVUETA: LA PELICULA %s NO EXISTE", tabla[j].codigo);
  230.         }
  231.         error=0;
  232.         if(tabla[j].operacion==BAJA)
  233.         {
  234.          p=*inicio;
  235.             while(p!=NULL)
  236.             {
  237.                 if (strcmp(p->cod, tabla[j].codigo)==0)
  238.                 {
  239.                     error=1;//quiere decir que existe el codigo y mostraremos un
  240.                     //mensaje de error
  241.                 }
  242.                 p=p->sig;
  243.             }
  244.          if(error==1)
  245.             {
  246.                 ante=p=*inicio;
  247.                 while(p!=NULL)
  248.                 {
  249.                     //borrar un registro pelicula entero
  250.                     if(strcmp(p->cod, tabla[j].codigo)==0)
  251.                     {
  252.                         if(ante==p)
  253.                         {
  254.                             *inicio=p->sig;
  255.                             free(p);
  256.                         }
  257.                         else if(p->sig!=NULL)
  258.                         {
  259.                             p=ante->sig;
  260.                             ante->sig=p->sig;
  261.                             free(p);
  262.                         }
  263.                     }
  264.                     else
  265.                     {
  266.                         ante->sig=NULL;
  267.                         free(p);
  268.                     }
  269.                 }
  270.                 ante=p;
  271.                 p=p->sig;
  272.             }
  273.          else
  274.                     printf("\nERROR BORRAR PELICULA: LA PELICULA %s NO EXISTE", tabla[j].codigo);
  275.         }
  276.     }
  277.  
  278.  
  279.  
  280. }
  281.  
  282. void ver_lista(nodo * inicio)
  283. {
  284.     int i;
  285.     nodo *p;
  286.     p=inicio;
  287.     printf("\n:.:Peliculas del Video-Club:.:\n");
  288.     gotoxy(1,1);
  289.     printf("CODIGO");
  290.     gotoxy(25,1);
  291.     printf("EXISTENCIAS");
  292.     for(i=1; i&lt;35; i++)
  293.     {
  294.         gotoxy(i,2);
  295.         printf("=");
  296.     }
  297.     i=3;
  298.     while(p!=NULL)
  299.     {
  300.         gotoxy(1,i);
  301.         printf("%s ", p->cod);
  302.         gotoxy(25,i);
  303.         printf("%d", p->existencias);
  304.         p=p->sig;
  305.         i++;
  306.     }
  307. }
  308.  
  309. void borrar_lista(nodo ** inicio)
  310. {
  311.     nodo *p;
  312.     p=*inicio;
  313.     while(p!=NULL)
  314.     {
  315.         *inicio=p->sig;
  316.         free(p);
  317.         p=*inicio;
  318.     }
  319.  
  320. }
  321.  
  322.  
  323. int menu()
  324. {
  325.     int resp;
  326.     do{
  327.         clrscr();
  328.         printf("----------------------------------------------------------------------\n");
  329.         printf("[1].- Cargar y crear lista de peliculas.\n");
  330.         printf("[2].- Cargar tabla de modificaciones. [Nuevas-devueltas-borrar]\n");
  331.         printf("[3].- Actualizar la lista enlazada con los valores de la tabla.\n");
  332.         printf("[4].- Visualizar almacen.\n");
  333.         printf("[5].- Salir.\n");
  334.         printf("----------------------------------------------------------------------\n\n");
  335.         printf("\t\t\tIntroducir opcion: ");
  336.         scanf("%d",&resp); fflush(stdin);
  337.     }while(resp!=1 && resp!=2 && resp!=3 && resp!=4 && resp!=5);
  338.     return(resp);
  339. }