La explicación es básicamente la que tienes arriba, con ejemplos incluidos. En cuanto a usar una u otra depende, aunque no hay mucha diferencia, la doblemente enlazada ocupa mas memoria pero también es mas rápida al obtener por ejemplo al nodo anterior al nodo dado.

http://es.wikipedia.org/wiki/Lista_%28inform%C3%A1tica%29#Listas_simples_enlazadas

LISTAS ENLAZADAS DOBLES

Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al valor NULL o a la lista vacía si es el primer nodo; y otro que apunta al siguiente nodo siguiente, o apunta al valor NULL o a la lista vacía si es el último nodo.

X <---. 12 .<======> .

Ejemplo:
#include<alloc.h>
#include<stdlib.h>
#include<conio.h>
#include<iostream.h>

//Estructuras Doblemente enlazadas
typedef struct nododoble
{
int dato;
struct nododoble *sig;
struct nododoble *ant;

}tipoNodo;

//PROTOTIPOS
tipoNodo *nuevo_elemento();
void creardoble();
void presentar();
void insertar();
void insertarfinaldoble();
void insertarordenadodoble();
void insertariniciodoble();
void modificar();
void buscar();
void ordenar();
void ordenardoblesasc();
void ordenardoblesdesc();
void eliminar();
void eliminar_cabeza();
void cuadro(int x1,int y1,int x2,int y2,char c);

tipoNodo *cab;
tipoNodo *cola;

tipoNodo *nuevo_elemento()
{
tipoNodo *nodo1;
nodo1=(tipoNodo *)malloc(sizeof(tipoNodo ));
if(!nodo1)
cout<<”No se ha reservado memoria para el nuevo “;
return nodo1;
}

//MENU PRINCIPAL
void main()
{
clrscr();
creardoble();
clrscr();
char opc=’ ‘;

do
{

clrscr();
cuadro(1,10,35,56,’’);
gotoxy(13,3);cout<<”->[ LISTAS ENLAZADAS DOBLES ]<-\n”;
gotoxy(12,6);cout<<” MENU PRINCIPAL\n”;
gotoxy(12,9); cout<<” [1]: INSERTAR \n”;
gotoxy(12,12);cout<<” [2]: MODIFICAR\n”;
gotoxy(12,15);cout<<” [3]: BUSCAR\n”;
gotoxy(12,17);cout<<” [4]: ORDENAR\n”;
gotoxy(12,19);cout<<” [5]: ELIMINAR\n”;
gotoxy(12,21);cout<<” [6]: PRESENTAR\n”;
gotoxy(12,24);cout<<” [7]: SALIR DEL MENU\n”;
gotoxy(12,27);cout<<” Elegir una Opci¢n [ ]“;
gotoxy(32,27);cin>>opc;

switch(opc)
{
case’1′:
clrscr();
insertar();;getch();break;
case’2′:
clrscr();
modificar();getch();break;
case’3′:
clrscr();
buscar();getch();break;
case’4′:
clrscr();
ordenar();getch();break;
case’5′:
clrscr();
eliminar();getch();break;

case’6′:
clrscr();
presentar();getch();break;

}

}while(opc!=’7′);

getch();

}

//CREAR LA CABEZA
void creardoble()
{
clrscr();
int dat;
gotoxy(20,20);
cout<<”Ingrese Elemento: “;
cin>>dat;
cab=nuevo_elemento();
cola=nuevo_elemento();
cab->dato=dat;
cab->sig=NULL;
cab->ant=NULL;
cola=cab;
getch();
}

void insertar()
{
clrscr();
char opc=’ ‘;

do
{

clrscr();
cuadro(1,10,25,56,’’);
gotoxy(13,3);cout<<”->[ INSERTAR ELEMENMTOS A LA LISTA ENLAZADA ]<-\n”;
gotoxy(12,6); cout<<” [1]: INSERTAR ORDENADO\n”;
gotoxy(12,9);cout<<” [2]: INSERTAR CABEZA\n”;
gotoxy(12,12);cout<<” [3]: INSERTAR AL FINAL\n”;
gotoxy(12,15);cout<<” [4]: REGRESAR\n”;
gotoxy(12,17);cout<<” Elegir una Opci¢n [ ]“;
gotoxy(32,17);cin>>opc;
switch(opc)
{
case’1′:
clrscr();
insertarordenadodoble();getch();break;

case’2′:
clrscr();

insertariniciodoble();getch();break;

case’3′:
clrscr();
insertarfinaldoble();getch();break;
}

}
while(opc!=’4′);

getch();

}

void insertarfinaldoble()
{
clrscr();
nododoble *elem;
elem=nuevo_elemento();
clrscr();
gotoxy(20,20);
cout<<”\t\t”<<”INGRESE VALOR :\t”;
cin>>elem->dato;
cola->sig=elem;
elem->sig=NULL;
elem->ant=cola;
cola=elem;
getch();
}

void insertarordenadodoble()
{
int dat;
nododoble *aux;
nododoble *ant;
nododoble *post;
aux=nuevo_elemento();
ant=nuevo_elemento();
post=nuevo_elemento();
gotoxy(18,22);
cout<<”Ingrese un elemento: “;
cin>>dat;
aux->dato=dat;
if(aux->dato>cab->dato)
{

ant=cab;
post=cab->sig;

while((aux->dato>post->dato) && (post->sig!=NULL))
{
ant=post;
post=post->sig;
}
if (post->sig==NULL)
{

if (aux->dato<post->dato){
aux->sig=post;
post->ant=aux;
ant->sig=aux;
aux->ant=ant;
}else{
aux->sig=NULL;
post->sig=aux;
aux->ant=post;
}
}
else
{
aux->sig=post;
post->ant=aux;
ant->sig=aux;
aux->ant=ant;
}
}
else{
aux->dato=dat;
aux->sig=cab;
cab->ant=aux;
aux->ant=NULL;
cab=aux;
}
}
void insertariniciodoble()
{
nododoble *Aux;
int dat;
Aux=nuevo_elemento();
gotoxy(18,22);
cout<<”Ingrese un numero:”;
cin>>dat;
Aux->dato=dat;
Aux->ant=NULL;
Aux->sig=cab;
cab->ant=Aux;
cab=Aux;
}

void modificar()
{
clrscr();
nododoble *modificar;
nododoble *ele;
modificar=nuevo_elemento();
int db,encontrado=0;
modificar=cab;
gotoxy(10,20);
cout<<”\t”<<”INGRESE EL VALOR A MODIFICAR :\t”;
cin>> db;
while(modificar!=NULL)
{
if(db==modificar->dato)
{
gotoxy(10,22);cout<<”Elemento existente en la lista”;
encontrado=1;
gotoxy(10,25);
cout<<”\t\t”<<”INGRESE VALOR :\t”;
cin>>ele->dato;
modificar->dato=ele->dato;

}
modificar=modificar->sig;

}
if(encontrado==0)
{
gotoxy(10,22);cout<<”Elemento no existente en la lista”;
}

getch();
}
void buscar()
{
clrscr();
nododoble *buscar;
buscar=nuevo_elemento();
int db,encontrado=0;
buscar=cab;
gotoxy(18,15);
cout<<”Ingrese el numero a buscar: “;
cin>> db;
while(buscar!=NULL)
{
if(db==buscar->dato)
{
gotoxy(18,18);cout<<”Elemento existente en la lista”;
encontrado=1;
}
buscar=buscar->sig;
}
if(encontrado==0)
{
gotoxy(18,18);cout<<”Elemento no existente en la lista”;
}
getch();
}

void ordenar()
{
clrscr();
char opc=’ ‘;

do
{

clrscr();
cuadro(1,10,25,56,’’);
gotoxy(13,3);cout<<”->[ ORDENAR LAS LISTAS ENLAZADAS ]<-\n”;
gotoxy(12,6);cout<<” MENU PRINCIPAL\n”;
gotoxy(12,9); cout<<” [1]: ORDENAR ASCENDENTE\n”;
gotoxy(12,12);cout<<” [2]: ORDENAR DESCENDENTE\n”;
gotoxy(12,15);cout<<” [3]: REGRESAR\n”;

gotoxy(12,17);cout<<” Elegir una Opci¢n [ ]“;
gotoxy(32,17);cin>>opc;
switch(opc)
{
case’1′:
clrscr();
ordenardoblesasc();break;
case’2′:
clrscr();
ordenardoblesdesc();break;

}

}
while(opc!=’3′);

getch();

}
void ordenardoblesasc()
{
nododoble *aux;
nododoble *temp;
int vaux;
aux=nuevo_elemento();
temp=nuevo_elemento();
aux=cab;
while (aux!=NULL)
{
temp=aux;
while(temp->sig!=NULL)
{
temp=temp->sig;
if(aux->dato>temp->dato)
{
vaux=aux->dato;
aux->dato=temp->dato;
temp->dato=vaux;
}
}
aux=aux->sig;
}
}
void ordenardoblesdesc()
{
nododoble *aux;
nododoble *temp;
int vaux;
aux=nuevo_elemento();
temp=nuevo_elemento();
aux=cab;
while (aux!=NULL)
{
temp=aux;
while(temp->sig!=NULL)
{
temp=temp->sig;
if(aux->dato<temp->dato)
{
vaux=aux->dato;
aux->dato=temp->dato;
temp->dato=vaux;
}
}
aux=aux->sig;
}
}

void presentar()
{
clrscr();

int c=8;
nododoble *recorre;
recorre=nuevo_elemento();
recorre=cab;
gotoxy(18,7);
cout<<” ELEMENTOS INSERTADOS: \n”;
while(recorre!=NULL)
{
c=c+1;
gotoxy(30,c);cout<<recorre->dato<<”\n”;
recorre=recorre->sig;
}
getch();
}

void eliminar()
{
presentar();
nododoble *eliminar;
nododoble *asigna;
gotoxy(10,25);cout<<”ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
gotoxy(10,26);cout<<”º º\n”;
gotoxy(10,27);cout<<”ºINSERTAR NUMERO A ELIMINARº\n”;
gotoxy(10,28);cout<<”º º\n”;
gotoxy(10,29);cout<<”ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;
gotoxy(10,31);cout<<”Ingrese el n—mero a eliminar\t”;
cin>>eliminar->dato;
if (eliminar->dato==cab->dato)
{

eliminar_cabeza();
}

else
{
nododoble *anterior=cab;
nododoble * aux=cab->sig;

while((aux!=NULL)&&(aux->dato!=eliminar->dato))
{
anterior=aux;
aux=aux->sig;
}
if(aux!=NULL)
{
asigna=aux->sig;
anterior->sig=asigna;
aux->ant=anterior;
aux->ant=NULL;
aux->sig=NULL;
free(aux);
}
else
{
gotoxy(10,33);
cout<<”NO SE ENCUENTRA”;
}
}

}

void eliminar_cabeza()
{
nododoble *aux;
aux=cab;
cab=cab->sig;
aux->sig=NULL;
aux->ant=NULL;
free(aux);
}

void cuadro(int x1,int y1, int x2, int y2, char simb)
{
for (int i1=y1;i1<=y2;i1++)
{
gotoxy(i1,x1);cout<<simb;
gotoxy(i1,x2);cout<<simb;
}
for (int i2=x1;i2<=x2;i2++)
{
gotoxy(y1,i2);cout<<simb;
gotoxy(y2,i2);cout<<simb;
}
}

mira Chicalight_ primero Una lista es un conjunto de elementos llamados nodos en los que cada uno de ellos contiene un dato y tambien la direccion del siguiente nodo, donde el orden de los mismos se establece mediante punteros.

LISTA ENLAZADA SIMPLE
La lista enlazada básica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a la lista vacía, si es el último nodo.

12.--->99.--->37

He aquì te dejo un ejemplo de una lista enlazada simple, ojala que te sirva como referencia:
#include<alloc.h>
#include<stdlib.h>
#include<conio.h>
#include<iostream.h>
//Declaramosla estructura
typedef struct nodo
{
int dato;
struct nodo * siguiente;
}tipoNodo;
//reservamos el espacio de memoria
tipoNodo *nuevo_elemento();

//Operaciones que vamos a arealizar
void crear();
void insertar();
void insertar_inicio();
void insertar_ordenado();
void insertar_final();
void presentar();
void modificar();
void buscar();
void ordenar();
void ordenar_ascendente();
void ordenar_descendente();
void eliminar();
void eliminar_cabeza();

//FUNCION PARA EL CUADRO
void cuadro(int x1,int y1, int x2, int y2, char simb);

//NUESTRA CABEZA
tipoNodo *cab;

tipoNodo *nuevo_elemento()
{
tipoNodo *nodo1;
nodo1=(tipoNodo *)malloc(sizeof(tipoNodo ));
if(!nodo1)
cout<<”No se ha reservado memoria para el nuevo “;
return nodo1;
}

void main()
{
clrscr();
crear();
clrscr();
char opc=’ ‘;

do
{

clrscr();
cuadro(1,10,35,56,’²’);
gotoxy(13,3);cout<<”->[ LISTAS ENLAZADAS ]<-\n”;
gotoxy(12,6);cout<<” MENU PRINCIPAL\n”;
gotoxy(12,9); cout<<” [1]: INSERTAR\n”;
gotoxy(12,12);cout<<” [2]: MODIFICAR\n”;
gotoxy(12,15);cout<<” [3]: BUSCAR\n”;
gotoxy(12,17);cout<<” [4]: ORDENAR\n”;
gotoxy(12,19);cout<<” [5]: ELIMINAR\n”;
gotoxy(12,21);cout<<” [6]: PRESENTAR\n”;
gotoxy(12,24);cout<<” [7]: SALIR DEL MENU\n”;

gotoxy(12,27);cout<<” Elegir una Opci¢n [ ]“;
gotoxy(32,27);cin>>opc;

switch(opc)
{
case’1′:
clrscr();
insertar();getch();break;
case’2′:
clrscr();
modificar();getch();break;
case’3′:
clrscr();
buscar();getch();break;
case’4′:
clrscr();
ordenar();getch();break;
case’5′:
clrscr();
eliminar();getch();break;

case’6′:
clrscr();
presentar();getch();break;

}

}while(opc!=’7′);

getch();

}
//CREANDO LA CABEZA
void crear()
{
clrscr();
cab=nuevo_elemento();
gotoxy(20,20);
cout<<”Ingrese valor de cabeza :\t”;
cin>>cab->dato;
cab->siguiente=NULL;
getch();
}
//MENU DE INSERTAR
void insertar()
{
clrscr();
char opc=’ ‘;

do
{

clrscr();
cuadro(1,10,35,56,’²’);
gotoxy(13,3);cout<<”->[ LISTAS ENLAZADAS ]<-\n”;
gotoxy(12,6);cout<<” MENU PRINCIPAL\n”;
gotoxy(12,9); cout<<” [1]: INSERTAR AL INICIO\n”;
gotoxy(12,12);cout<<” [2]: insertar AL FINAL\n”;
gotoxy(12,15);cout<<” [3]: INSERTAR ORDENADO\n”;
gotoxy(12,18);cout<<” [4]: REGRESAR\n”;

gotoxy(12,21);cout<<” Elegir una Opci¢n [ ]“;
gotoxy(32,21);cin>>opc;

switch(opc)
{
case’1′:
clrscr();
insertar_inicio();getch();break;
case’2′:
clrscr();
insertar_final();getch();break;
case’3′:
clrscr();
insertar_ordenado();getch();break;

}

}while(opc!=’4′);

getch();

}

//INSERATAR AL INICIO
void insertar_inicio()
{
clrscr();
nodo *pAuxElem;
nodo *recorre;
pAuxElem=(tipoNodo*) malloc(sizeof(tipoNodo));
while(recorre->siguiente!=NULL)
{
recorre=recorre->siguiente;
}
int n;
gotoxy(20,20);
cout<<”INGRESE VALOR :\t”;
cin>>n;
pAuxElem->dato=n;
pAuxElem->siguiente=cab;
cab=pAuxElem;
}

//INSERTAR AL FINAL
void insertar_final()
{
clrscr();
nodo *elem;
elem=nuevo_elemento();
clrscr();
gotoxy(20,20);
cout<<”INGRESE VALOR :\t”;
cin>>elem->dato;
nodo *recorrer;
recorrer=cab;
while(recorrer->siguiente!=NULL)
recorrer=recorrer->siguiente;
recorrer->siguiente=elem;
elem->siguiente=NULL;
getch();
}
//INSERATAR ORDENADO
void insertar_ordenado()
{
clrscr();
nodo *pAuxElem;
nodo *post;
nodo *recorre;
pAuxElem=(tipoNodo*) malloc(sizeof(tipoNodo));
post=(tipoNodo*) malloc(sizeof(tipoNodo));
int n;
gotoxy(20,20);
cout<<”INGRESE VALOR :\t”;
cin>>n;
if(n<cab->dato)
{

post=cab->siguiente;
while((pAuxElem->dato>post->dato)&&(post->siguiente!=NULL))
{
post=post->siguiente;
}
if(post->siguiente!=NULL)
{
pAuxElem->siguiente=cab;
cab=pAuxElem;
}
else
{
pAuxElem->siguiente=NULL;
post->siguiente=pAuxElem;
}

}
else
{
while(recorre->siguiente!=NULL)
{
recorre=recorre->siguiente;
}
pAuxElem->dato=n;
pAuxElem->siguiente=cab;
cab=pAuxElem;
}
/*cout<<”Ingrese un numero”;
cin>>n;
if(n>cab->dato)
{
insertar_inicio(n);
}
else
{
nodo *aux;
nodo *ant;
aux=cab->siguiente;
while((aux!=NULL)(n>aux->dato))
{
ant=aux;
aux=aux->siguiente
}
nodo *nuevo;
nuevo=crear_nuevo();
nuevo->dato=n;
ant->siguiente=nuevo;
nuevo->siguiente=aux;
}*/

}
//PARA MODIFICAR
void modificar()
{
clrscr();
nodo *elem;
nodo *ele;
gotoxy(10,25);cout<<”ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
gotoxy(10,26);cout<<”º º\n”;
gotoxy(10,27);cout<<”ºMODIFICAR NUMERO DE LISTA º\n”;
gotoxy(10,28);cout<<”º º\n”;
gotoxy(10,29);cout<<”ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;
gotoxy(20,20);
cout<<”INGRESE EL VALOR A MODIFICAR :\t”;
cin>>elem->dato;
nodo *recorrer;
recorrer=cab;
while(recorrer!=NULL)
{

if(recorrer->dato==elem->dato)
{
clrscr();
gotoxy(20,20);
cout<<”INGRESE VALOR :\t”;
cin>>ele->dato;

recorrer->dato=ele->dato;
}
recorrer=recorrer->siguiente;

}
getch();
}
//PARA BUSCAR
void buscar()
{
clrscr();
nodo *elem;
gotoxy(10,25);cout<<”ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
gotoxy(10,26);cout<<”º º\n”;
gotoxy(10,27);cout<<”ºBUSCADOR DE NUMERO DE LISTAº\n”;
gotoxy(10,28);cout<<”º º\n”;
gotoxy(10,29);cout<<”ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;
gotoxy(20,20);
cout<<”INGRESE EL VALOR A BUSCAR :\t”;
cin>>elem->dato;
nodo *recorrer;
recorrer=cab;
while(recorrer!=NULL)
{

if(recorrer->dato==elem->dato)
{
clrscr();
gotoxy(20,20);
cout<<elem->dato<<”:\t”;
cout<<”ESTE ELEMENTO SI EXISTE”;
recorrer->dato=elem->dato;
}

recorrer=recorrer->siguiente;

}

getch();
}
//ORDENAR
void ordenar()
{
clrscr();
char opc=’ ‘;

do
{

clrscr();
cuadro(1,10,25,56,’²’);
gotoxy(13,3);cout<<”->[ ORDENAR LAS LISTAS ENLAZADAS ]<-\n”;
gotoxy(12,6);cout<<” MENU PRINCIPAL\n”;
gotoxy(12,9); cout<<” [1]: ORDENAR ASCENDENTE\n”;
gotoxy(12,12);cout<<” [2]: ORDENAR DESCENDENTE\n”;
gotoxy(12,15);cout<<” [3]: REGRESAR\n”;

gotoxy(12,17);cout<<” Elegir una Opci¢n [ ]“;
gotoxy(32,17);cin>>opc;
switch(opc)
{
case’1′:
clrscr();
ordenar_ascendente();getch();break;
case’2′:
clrscr();
ordenar_descendente();getch();break;

}

}
while(opc!=’3′);

getch();

}

void ordenar_ascendente()
{
nodo* aux;
nodo* temp;
int vaux;
aux=(tipoNodo *)malloc(sizeof(tipoNodo));
temp=(tipoNodo *)malloc(sizeof(tipoNodo));
aux=cab;
while (aux!=NULL)
{
temp=aux;
while(temp->siguiente!=NULL)
{
temp=temp->siguiente;
if(aux->dato>temp->dato)
{
vaux=aux->dato;
aux->dato=temp->dato;
temp->dato=vaux;
}
}
aux=aux->siguiente;
}
}

void ordenar_descendente()
{
nodo* aux;
nodo* temp;
int vaux;
aux=(tipoNodo *)malloc(sizeof(tipoNodo));
temp=(tipoNodo *)malloc(sizeof(tipoNodo));
aux=cab;
while (aux!=NULL)
{
temp=aux;
while(temp->siguiente!=NULL)
{
temp=temp->siguiente;
if(aux->dato<temp->dato)
{
vaux=aux->dato;
aux->dato=temp->dato;
temp->dato=vaux;
}
}
aux=aux->siguiente;
}
}
//ELIMINAR
void eliminar()
{
presentar();
nodo *eliminar;
// nodo *recorrer;
nodo *asigna;
gotoxy(10,25);cout<<”ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
gotoxy(10,26);cout<<”º º\n”;
gotoxy(10,27);cout<<”ºINSERTAR NUMERO A ELIMINARº\n”;
gotoxy(10,28);cout<<”º º\n”;
gotoxy(10,29);cout<<”ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;
gotoxy(10,31);cout<<”Ingrese el n—mero a eliminar\t”;
cin>>eliminar->dato;
// recorrer=cab;
if (eliminar->dato==cab->dato)
{

eliminar_cabeza();
}

else
{
nodo *anterior=cab;
nodo * aux=cab->siguiente;

while((aux!=NULL)&&(aux->dato!=eliminar->dato))
{
anterior=aux;
aux=aux->siguiente;
}
if(aux!=NULL)
{
anterior->siguiente=aux->siguiente;
aux->siguiente=NULL;
free(aux);
}
else
{
gotoxy(10,33);
cout<<”NO SE ENCUENTRA”;
}
}

}
//ELIMINAR CABEZA
void eliminar_cabeza()
{
nodo *aux;
aux=cab;
cab=cab->siguiente;
aux->siguiente=NULL;
free(aux);
}
//PRESENTAR LA LISTA
void presentar()
{
clrscr();
int f=10;
nodo *recorrer;
recorrer=cab;
gotoxy(20,f);
while(recorrer!=NULL)
{
gotoxy(20,f);
cout<<recorrer->dato;
cout<<”\n\n”;
recorrer=recorrer->siguiente;
f=f+2;
}
getch();

}
//ESTA FUNCION PERMITE PRESENTAR LOS BORDES DE UN CUADRO
void cuadro(int x1,int y1, int x2, int y2, char simb)
{
for (int i1=y1;i1<=y2;i1++)
{
gotoxy(i1,x1);cout<<simb;
gotoxy(i1,x2);cout<<simb;
}
for (int i2=x1;i2<=x2;i2++)
{
gotoxy(y1,i2);cout<<simb;
gotoxy(y2,i2);cout<<simb;
}
}

Hola a todos, mi duda es la siguiente... no sé en que momento utilizar listas simples o dobles, yo por mi ocuparia puras simplemente enlazadas.. Esa es mi duda cuando es conveniente utilizar cada cual con ejemplos de casos por favorrr...
por ejemplo si quiero hacer una lista de clientes en cierta consulta de un doctor en tal dia... conviene que sea simple o doble?'? en que casos seria mejor una doble?

Buenas!

Mas que dudas de programación, da la sensación de que nos encargas un trabajo o una práctica...

Una lista es una lista, lo que hagas luego con ella es lo que simula un almacén, una tienda de motos o lo que sea...por otro lado el entorno de desarrollo (NetBeans, Eclipse, etc) no tiene nada que ver con la interfaz gráfica...lo único que existen algunos plugins para desarrollar de manera mas ágil y visual las aplicaciones.

Si pudieras concretar mas tu duda ayudaría bastante,

Un saludo.

Una lista que describa la forma en que un almacen funciona(venta,compra,cantidad de objetos) y una forma simple de crear una interfase grafica en el programa netbeans si es posible.