Un ensayo de linked list ...

#include <iostream>
using namespace std;

//------------------------------------------------------------------------------------------
struct nodo{ nodo* izq ;int dato;nodo *der;};//@direccion <- dato -> @direccion
//------------------------------------------------------------------------------------------
class nodos{
    public:
    nodos();
    nodo* creaNodo(int dato);//Crea un Nodo
    void leeNodos();//Lee los nodos disponibles
    nodo* buscaNodo(int dato);//Busca un nodo
    void borraNodo(nodo* direccion);//Borra un nodo por su direccion
    void borraNodo(int dato);//Borra un nodo por dato

    private:
    void leeUnNodo(nodo* unNodo);//Lee ,imprime datos de un solo NODO
    nodo* primerNodo(nodo* unNodo);//Rebobina al primer nodo
    nodo* actual;
};
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
nodos::nodos():actual(nullptr){};
//------------------------------------------------------------------------------------------
nodo* nodos::creaNodo(int dato){
    nodo* nuevoNodo=new nodo();//Crea un nuevo nodo

    if (actual!=nullptr ) {actual->der=nuevoNodo;} //afecta em nodo anterior con la direccion del nodo recien creado

    nuevoNodo->dato=dato;//inicializa el dato
    nuevoNodo->izq=actual;//Inicializa con la direccion del nodo anterior o Null
    nuevoNodo->der=nullptr;//aun no existe ...
    actual=nuevoNodo; //Actualizo el Nodo actual
    return nuevoNodo;
}
//------------------------------------------------------------------------------------------
nodo* nodos::primerNodo(nodo* unNodo){//Rebobina al primer nodo
    while (unNodo->izq!=nullptr){//Mientras que no llegue al primer nodo
        unNodo=unNodo->izq;//sigue bajando a izquierda
    }
    return unNodo;//retorna el nodo inferior
}
//------------------------------------------------------------------------------------------
void nodos::leeUnNodo(nodo* unNodo){//Lee ,imprime datos de un solo NODO
    if (unNodo==nullptr){return;}
    cout <<"NODO & "<<unNodo
    <<"\t , izq &"<<unNodo->izq
    <<"\t , der &"<<unNodo->der
    <<" , dato = "<<unNodo->dato<<endl;
}
//------------------------------------------------------------------------------------------
void nodos::leeNodos(){//Lee los nodos disponibles
    nodo* tmp(actual);
    actual=primerNodo(actual);//Rebobina al primero

    while (actual!=nullptr){//Mientras que no llegue al ultimo nodo
        leeUnNodo(actual);//Lee ,imprime datos de un solo NODO
        actual=actual->der;//sigue subiendo
    }
    actual=tmp;
}
//------------------------------------------------------------------------------------------
nodo* nodos::buscaNodo(int dato){//Busca un nodo
    nodo* tmp;
    actual=primerNodo(actual) ;//Rebobina al NODO[0]

    //busca el dato en cada NODO en la lista
    while (actual!=nullptr ){//Ha llegado al final de la lista de nodos ?

        if (actual->dato==dato){//encotrado ?
                cout <<" Encontrado "<<actual->dato<<endl;
                leeUnNodo(actual);
                return actual;
            }//encontrado retorna nodo

            tmp=actual;
            actual=actual->der; //sigue subiendo hasta el final de la lista
    }
    actual=tmp;

    cout << dato <<" No encontrado  ! "<<endl;
    return nullptr;//no encotrado retorna nullo
}
//------------------------------------------------------------------------------------------
void nodos::borraNodo(nodo* direccion){//Borra un nodo por su direccion
    //Cose ,afecta nudos  laterales si existen
    if (direccion->izq!=nullptr){
        (direccion->izq)->der=direccion->der;
        actual=direccion->izq;
        }

    if (direccion->der!=nullptr){
        (direccion->der)->izq=direccion->izq;
        actual=direccion->der;
        }

    cout <<"actual "<<actual<<endl;
    delete (direccion) ;//Borra el nodo
}
//------------------------------------------------------------------------------------------
void nodos::borraNodo(int dato){//Borra un nodo por dato
    nodo* tmp;
    if ((tmp=buscaNodo(dato)) ==nullptr ){return ;} //No encontrado retorna
    else{ borraNodo (tmp);}//borra por direccion ,funcion anterior
}
//------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------
int main (){
    nodos Nodos;

    //Crear una lista de nodos de forma automatica
    for (int dato=100;dato<2000;dato+=100){
        Nodos.creaNodo(dato);
    }

   // Nodos.leeNodos();//Lectura de los Nodos, direccion y datos
    Nodos.borraNodo(300);
    Nodos.borraNodo(400);

    Nodos.borraNodo(100);
    Nodos.borraNodo(1900);
    Nodos.borraNodo(1950);
    Nodos.leeNodos();
}