#include <iostream>

using namespace std;

enum {kEsNombre,kEsTelefono,kEsDireccion,kEsCorreo};

class Datos
{
public:

Datos(int);

~Datos() {}

int Comparar(const Datos &);

void Mostrar();
private:
int miNombre;
};

Datos::Datos(int nom):miNombre(nom)
{}

int Datos::Comparar(const Datos & losOtrosDatos)

{
if(miNombre<losOtrosDatos.miNombre)
return kEsNombre;
if(miNombre<losOtrosDatos.miNombre)
return kEsTelefono;

else if(miNombre>losOtrosDatos.miNombre)
return kEsDireccion;
else
return kEsCorreo;
}

void Datos::Mostrar()
{
cout << miNombre << endl;
}

class Nodo
{
public:

Nodo() {};

virtual ~Nodo() {};

 virtual Nodo * Insertar(Datos * losDatos)=0;
virtual void Mostrar()=0;
};

class NodoInterno: public Nodo

{
public:

NodoInterno(Datos * losDatos, Nodo * siguiente);

~NodoInterno();
virtual Nodo * Insertar(Datos * losDatos);
virtual void Mostrar();
private:

Datos * misDatos;

Nodo * miSiguiente;
};

NodoInterno::NodoInterno(Datos * losDatos, Nodo * siguiente):

misDatos(losDatos), miSiguiente(siguiente)
{}

NodoInterno::~NodoInterno()
{
delete miSiguiente;
delete misDatos;
}

Nodo * NodoInterno::Insertar(Datos * losDatos)

{

int resultado=misDatos->Comparar(*losDatos);
switch(resultado)
{

case kEsCorreo:

case kEsTelefono:
case kEsDireccion:

{
NodoInterno * nodoDatos=new
NodoInterno(losDatos,this);
return nodoDatos;
}

case kEsNombre:
miSiguiente=miSiguiente->Insertar(losDatos);
return this;
 }
return this;
}

void NodoInterno::Mostrar()
{

misDatos->Mostrar();

miSiguiente->Mostrar();
}

class NodoCola: public Nodo

{

public:

NodoCola() {}

~NodoCola() {}

virtual Nodo * Insertar(Datos * losDatos);

virtual void Mostrar() {}
};

Nodo * NodoCola::Insertar(Datos * losDatos)

{
NodoInterno * nodoDatos = new NodoInterno(losDatos,this);
return nodoDatos;
}

class NodoCabeza: public Nodo

{
public:

NodoCabeza();

~NodoCabeza();

virtual Nodo * Insertar(Datos * losDatos);

virtual void Mostrar();
private:
Nodo * miSiguiente;
};

NodoCabeza::NodoCabeza()
{

miSiguiente=new NodoCola;
}
NodoCabeza::~NodoCabeza()
{
delete miSiguiente;
}

Nodo * NodoCabeza::Insertar(Datos * losDatos)

{
miSiguiente=miSiguiente->Insertar(losDatos);
return this;
}

void NodoCabeza::Mostrar()
{
miSiguiente->Mostrar();
}

class ListaEnlazada
{
public:

ListaEnlazada();

~ListaEnlazada();

void Insertar(Datos * losDatos);

void MostrarTodo();
private:
NodoCabeza * miCabeza;
};

ListaEnlazada::ListaEnlazada()
{

miCabeza=new NodoCabeza;
}

ListaEnlazada::~ListaEnlazada()
{
delete miCabeza;
}

void ListaEnlazada::Insertar(Datos * apDatos)

{
miCabeza->Insertar(apDatos);
}

void ListaEnlazada::MostrarTodo()
{
miCabeza->Mostrar();
}

int main()
{
 Datos * apDatos;
int nom;
ListaEnlazada le;

for(;;)
{

cout << "Indica un nombre : (0 para terminar) ";

cin >> nom;

if(nom)
break;
apDatos=new Datos(nom);
le.Insertar(apDatos);
}

le.MostrarTodo();

return 0;
}