Ejercicios de listas simples y dobles en c++

El siguiente código es para que ingreses números, eligiendo la opción en un menú
y mientras ingresas, puedes elegir ver la lista como se ve. Sigue leyendo después del código.
#include <iostream.h>
#include <stdlib.h>
#include <conio.h>
struct nodo{
int info;
nodo *sgt;
};
void agrega(nodo **cab, nodo **fin);
void muestra(nodo *cab);
int main()
{ nodo *c=NULL,*f=NULL;  //puntero de cabecera, y puntero de fin de lista
  int opcion;
   do{
   system("cls");
   cout<<"1) Ingresa un dato (numero entero)."<<endl;
   cout<<"2) Muestra los datos ingresados."<<endl;
  cout<<"ingrese opcion"<<endl;
  cin>>opcion;
  switch(opcion){
  case 0: exit(0);break;
  case 1: agrega(&c, &f);break;
  case 2: muestra(c);break;
  }
  }
  while(opcion!=0);
      system("PAUSE");
      return 0;
}
void agrega(nodo **cab, nodo **fin){
int num;
cout<<"ingrese informacion"<<endl;
cin>>num;
if((*cab)==NULL){
*cab = new nodo;
(*cab)->info =num;
(*cab)->sgt=NULL;
(*fin)=(*cab);
}else{
(*fin)->sgt=new nodo;
(*fin)->sgt->info=num;
(*fin)=(*fin)->sgt;
(*fin)->sgt=NULL;
}
}
void muestra(nodo *cab){
cout<<"elementos en la lista"<<endl;
nodo* temp;
temp=cab;
while ( temp != NULL){
cout<<temp->info<<"   ";
temp=temp->sgt;
}
getche();
}
BUeno, para hacer listas enlazadas simples, solo creas un puntero de cabecera, en este caso llamado c, y uno de fin de lista, llamado f para hacer la inserción más rápida.
Como ves, en la lista simple, tienes una estructura con un puntero sgt, que apunta al siguiente nodo.
En la lista doble, tendrás que crear otro campo, llamado ant. para que apunte al anterior
cuando vas ingresando elementos, como dice el siguiente código.
void agrega(nodo **cab, nodo **fin){
int num;
cout<<"ingrese informacion"<<endl;
cin>>num;
if((*cab)==NULL){
*cab = new nodo;
(*cab)->info =num;
(*cab)->sgt=NULL;
(*fin)=(*cab);
}else{
(*fin)->sgt=new nodo;
(*fin)->sgt->info=num;
(*fin)=(*fin)->sgt;
(*fin)->sgt=NULL;
}
}
Como ves, ingresas el dato, llamado num, y verificas si la cabeza (cab) es nula, si es nula se crea new nodo, que será el primero y será apuntado por cab, indicando el inicio de la lista, y el fin también a la vez. Si no es nulo, entonces solo tomas al puntero fin, ingresas a su campo sgt, y creas new nodo, stg esta apuntando al siguiente nodo, y puedes ingresar a su campo info haciendo (*fin)->sgt->info=num; y de paso igualas con num para agregar el nuevo valor. Ahora el fin es otro, por que hay uno nuevo, entonces haces
(*fin)=(*fin)->sgt;
Eso es para listas simples, si quieres ingresar datos para listas dobles, es muy similar. Solo que ahora el puntero fin, será como tu OTRA CABEZA, osea que si quieres recorrerlo en sentido contrario, solo haces primero referencia a ese puntero, y ya no a cab.
La estructura se modifica como te dije en un campo, le agregas el puntero ant. y ahora tendrás que modificar también tu modo de ingreso.
Primero te fijas en la cab si es null, si es null entonces se hace el mismo proceso. Solo que ahora tienes que tener en cuenta que existe ant y lo igualas a null como se hace con sgt.
Pero si cab no es null, entonces haces referencia a fin, haces new nodo con fin->sgt.
(*fin)->sgt=new nodo;
ingresas el dato en el siguiete nodo.
(*fin)->sgt->info=num;
Antes de hacer pasar a fin al siguiente nodo, igualas al campo ant del siguiente nodo a fin, ya que fin en este momento está apuntando al ANTERIOR DEL NUEVO NODO.
(*fin)->sgt->ant=(*fin);
Ahora si, este nodo está siendo apuntado por el ant del ultimo nodo (el nuevo nodo creado), y ahora si podemos pasar a fin al ultimo nodo
(*fin)=(*fin)->sgt;
haces fin->sgt a null y listo.
(*fin)->sgt=NULL;
Con esto el ingreso de datos para tu lista enlazada está terminada. Ahora solo te falta el recorrido, pero es el mismo. Si tomas a cab de inicio, entonces tendrás que recorrerlo pasando por los punteros sgt de cada nodo.
temp = cab;
while ( temp != NULL){
cout<<temp->info<<"   ";
temp=temp->sgt;
}
pero si quieres recorrerlo del ultimo al primero, entonces tendras que hacer el recorrido tomando a fin como inicio y temp se pasará por los campos ant de cada nodo
temp = fin;
while ( temp != NULL){
cout<<temp->info<<"   ";
temp=temp->ant;
}
Con esto está tu algoritmo terminado en un 80 por ciento. Solo te faltaría intercalar los datos, que es cosa fácil. Si tienes alguna duda, o quieres otra ayuda solo avisame.