Lista Ordenada

#include <conio.h>
#include <stdio.h>
#include <windows.h>
#include <ctype.h>
#include <stdlib.h>

struct lista {
       int clave;
       char descrip[25];
       struct lista *sigptr; };
typedef struct lista LISTA;
typedef LISTA *LSTPTR;

void imprime(LSTPTR auxptr)/*auxptr ya apunta al inicio de la lista porque en el llamado de la función se le esta
pasando el valor de iniptr*/
{
    if(auxptr==    NULL)
    {
        printf("\nno hay lista");
    }
    else
    {
        while(auxptr!=NULL)
        {
            printf("|<  %d, %s", auxptr->clave, auxptr->descrip);
           auxptr=auxptr->sigptr;
        }
    }
    getch();
}
void enlista(LSTPTR *iniptr/*iniptr que apunta  al inicio de la lista y tiene la direccion de memoria de iniptr
 que se encuentra en main*/, LSTPTR *finptr, int cla, char descr[25])
{ LSTPTR nvoptr, actptr, otroptr;
  nvoptr = (LSTPTR) malloc(sizeof(LISTA));// a nvo ptr se le asigna un espacio en memoria del tamaño de la estrucutura lista
  if (nvoptr != NULL)//preguntar si se reservo el espacio
     {nvoptr->clave = cla;//el valor de cla, valor solicitado en el main, sera asignado al miembro clave que esta siendo apuntado por nvoptr
      strcpy(nvoptr->descrip, descr);//se copia la cadena descr que se encuentra en main hacia descrip que es miembro del nodo
      nvoptr->sigptr = NULL;//asignar valor nulo al miembro sigptr que esta siendo apuntado por nvoptr
      if (*iniptr == NULL)//si la variable que esta siendo apuntada por iniptr o sea iniptr del main es nula
     {*iniptr/*la variable que esta siendo apuntada por iniptr o sea iniptr del main*/ = nvoptr;//al iniptr del main se le asigna la direccion de nvoptr o sea el nodo completo
      *finptr = nvoptr;//al finptr del main se le asigna la direccion de nvoptr o sea el nodo completo
     }
      else
     {actptr = *iniptr;//asignar el valor de la variable que esta siendo apuntada por iniptr al apuntador actptr
      if (cla < (*iniptr)->clave)//si cla es menor que clave, y clave esta siendo apuntada por actptr aunque se tiene q referir a iniptr
        {nvoptr->sigptr = *iniptr;
         *iniptr = nvoptr;
        }
     else
        if (cla > (*finptr)->clave)//si cla es mayor que la variable clave del main
           {(*finptr)->sigptr = nvoptr;//el valor de la variable nvoptr va a ser asiganado a sigptr que esta siendo apuntada por la variable q esta siendo apuntada por finptr
        *finptr = nvoptr;//el valor de nvoptr sera asignado a finptr
           }
        else
           {otroptr = actptr->sigptr;//a otroptr se el asigna el valor de sigptr que esta siendo apuntada por actptr
        while (cla > otroptr->clave)//mientras que cla sea mayor que clave que esta siendo apuntado por otroptr
              {actptr= actptr->sigptr;//el valor del miembro sigptr que esta siendo apuntado por actptr, se asigna a actptr
               otroptr= actptr->sigptr;
              }
        actptr->sigptr = nvoptr;
        nvoptr->sigptr = otroptr;
           }
     }
     }
  else
      printf("%d no fue insertado. No hay memoria disponible\n\n", cla);
}

void menu(void)
     { system("cls");
       printf("\n\n\n\n"
          "              OPERACIONES DISPONIBLES EN LA LISTA ORDENADA: \n\n\n\n"
          "              1 AGREGAR UN ELEMENTO A LA LISTA\n"
          "              2 IMPRIMIR LA LISTA\n"
          "              3 EXTRAER UN ELEMENTO DE LA LISTA\n"
          "              4 SALIR DEL PROGRAMA\n");
     }

main()
{ LSTPTR iniptr = NULL/*apuntador al inicio de la lista*/, finptr = NULL/*apuntador al final de la lista*/;
  char opcion, descri[25];//variables para capturar los datos solicitados
  int clav;//datos solicitados
  menu();
  printf("\n                Elige opcion: ");
  scanf("%c", &opcion);
  while (opcion != '4')
        { switch(opcion)
                { case '1': printf("\n                Clave del articulo (entero): ");
                            scanf("%d", &clav);
                            fflush(stdin);
                            printf("\n                  Descripcion del articulo : ");
                            gets(descri);
                            enlista(&iniptr/*parametro q pasa la direccion de memoria del apuntador del inicio de la lista a la función enlista*/, &finptr, clav, descri)           ;//funcio para insertar a la lista
                            break;
                  case '2': imprime(iniptr);
                              break;
                  /*case '3': extrae(&iniptr,&finptr,clav);
                              break;*/
                  default : printf("\n\n Opcion no valida.....");
                            printf("\n\n Enter para continuar...");
                            getch();
                            break;
                }
          menu();
          fflush(stdin);
          printf("\n                Elige opcion: ");
          scanf("%c", &opcion);
        }
  printf("\n                Fin del programa.\n\n");
  printf("                Enter para terminar...");
  getch();
}

Colas

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

struct colanodo {
       int clave;
       char descrip[20];
       struct colanodo *sigptr;};//apuntador del tipo estructura colanodo

typedef struct colanodo COLANODO;
typedef COLANODO *COLANODOPTR;

void enqueue(COLANODOPTR *, COLANODOPTR *, int, char[]);//se pone el asterisco porque
void menu(void);
void imprime(COLANODOPTR);
void dequeue(COLANODOPTR *);

main()
{ COLANODOPTR adelaptr = NULL/*apuntador al inicio de la cola*/, atrasptr = NULL/*final de la cola*/;
  int opcion, clav;
  char descri[20];
  menu();//llamada al funcion menu
  printf("\n                Elige opcion: ");
  scanf("%d", &opcion);

  while (opcion != 4)
        { switch(opcion)
                { case 1: printf("\n                INSERCION EN LA COLA");  
                          printf("\n\n                Clave del articulo:  ");
                          scanf("%d", &clav);
                          fflush(stdin);
                          printf("\n          Descripcion del articulo:  ");
                          gets(descri);
                          enqueue(&adelaptr, &atrasptr, clav, descri);
                          break;
                  case 2:
                                dequeue (&adelaptr);
                  break;
                  case 3:
                                imprime (adelaptr);
                  break;
                          //llamado de la función imprime: imprime(adelaptr);
                  default : printf("\n                Opcion no permitida.\n\n");
                            printf("                Enter para continuar...");
                            getch();
                            menu();
                            break;
                }
          menu();
          printf("\n                Elige opcion: ");
          scanf("%d", &opcion);
        }
  printf("\n                Fin del programa.\n\n");
  printf("\n                Enter para salir...");
  getch();
}

void menu(void)
     { system("cls");
       printf("\n\n\n\n"
          "              OPERACIONES DISPONIBLES CON LA COLA: \n\n\n\n"
          "              1 (enqueue) AGREGAR UN DATO A LA COLA\n"
          "              2 (dequeue) ELIMINAR UN DATO DE LA COLA\n"
          "              3 IMPRIMIR LA COLA\n"
          "              4 SALIR DEL PROGRAMA\n");
     }

void enqueue(COLANODOPTR *adelaptr/*se declara un apuntador, al apuntador *adelaptr de la función main*/,
COLANODOPTR *atrasptr/*apuntador que apunta a *atrasptr de la función main*/, int cla, char desc[20])
     { COLANODOPTR nvoptr;
       nvoptr = (COLANODOPTR) malloc(sizeof(COLANODO));//se le asigna un espacio en memoria del tamaño de colanodo
       if (nvoptr != NULL) {
       nvoptr->clave = cla;//el miembro clave que esta siendo apuntado por nuevoptr asignale el valor de cla
       strcpy(nvoptr->descrip, desc);/*en la función para copiar string: en la cadena desc vamos a copiar lo que hay en descrip
       que esta siendo apuntada por nvoptr*/
       nvoptr->sigptr = NULL; /* a sigptr que se encuentra en cada elemento de la cola, que esta siendo apuntado por nvoptr
        le asignamos un valor nulo*/
       if (*adelaptr==NULL)//if para agregar el primer nodo de la cola
           *adelaptr = nvoptr;
       else//si ya hay un elemento(S) en la cola los nuevos se van formando atras/* entonces se entra al else*/
          (*atrasptr)->sigptr = nvoptr;/*el valor de nvoptr se lo asignamos a sigptr que esta siendo apuntado
           por la variable que esta siendo apuntada por atrasptr<el ultimo elemento que fue ingresado es apuntado por atrasptr
           del main, entonces ordenamos que el apuntador en ese nodo apunte hacia la posición de arriba>*/
       *atrasptr = nvoptr;/*al cumplirse cualquiera de las condiciones anteriores el valor de nuevoptr es asignado al atrasptr
       del main para reconocerlo como el nuevo final de la cola*/
       }
       else//else del if principal que nos indica que no se encontro memoria disponible
      printf("%c %s no fue insertado. No hay memoria disponible\n\n", cla, desc);
       }
void imprime(COLANODOPTR auxptr)
{
    if(auxptr==NULL)
    printf("no hay cola\n");
    else
    {
        while(auxptr!=NULL)
        {
            printf("\n %d %s", auxptr->clave, auxptr->descrip);
             auxptr= auxptr->sigptr;
        }
        printf("\nfin de la cola");
    }
    getch();
}
void dequeue(COLANODOPTR *adelaptr)
{
    COLANODOPTR auxptr;
    auxptr=*adelaptr;
    if(auxptr==NULL)
    {
        printf("\n no hay elementos en la cola");
    }
    else
    {
        (*adelaptr)=auxptr->sigptr;
        printf("\n el producto de clave: %i-- y descripcion: %s fue eliminado",auxptr->clave, auxptr->descrip);
        free(auxptr);
    }
    getch();
}