Ejercicio 46

#include <iostream>
// se incluye la clase Nino para despues llamar a sus metodos 
#include "Nino.h"
// se incluye la clase ProgramaDepartamental para despues llamar a sus metodos 
#include "ProgramaDepartamental.h"
// se incluye la clase stdlib para poder utilizar el metodo system que nos permitira utilizar los comandos basicos de la consola, en este caso lo utilizaremos para limpiar la pantalla de la consola system("cls")  
#include "stdlib.h"

using namespace std;

// método para llenar la lista 
void llenar(Nino *nod)
{
    int e, n_r, p, id, m;
    string n, n_p;
    float a;
    // con el ciclo do while comprobare que la edad este entre el rango de 1 y 6 años 
    do
    {
        cout << "Ingrese edad del nino" << endl;
        cout << ">> ";
        cin >> e;
    }
    while (e < 1 || e > 6);
    // encapsulo la variable e 
    nod->setEdad(e);
    // se pide el nombre del niño 
    cout << "Ingrese nombre del nino" << endl;
    cout << ">> ";
    cin >> n;
    // encapsulo la variable n 
    nod->setNombre(n);
    // se pide el registro civil del niño 
    cout << "Ingrese numero de registro civil del nino" << endl;
    cout << ">> ";
    cin >> n_r;
    // encapsulo la variable n_r 
    nod->setRegistroCivil(n_r);
    // se pide la altura del niño 
    cout << "Ingrese altura del nino" << endl;
    cout << ">> ";
    cin >> a;
    // se encapsula la variable a 
    nod->setAltura(a);
    // se pide el peso del niño 
    cout << "Ingrese peso del nino:" << endl;
    cout << ">> ";
    cin >> p;
    // se encapsula la variable p 
    nod->setPeso(p);
    // se pide el numero de identificacion del padre 
    cout << "Ingrese numero de identificacion del padre/madre del nino" << endl;
    cout << ">> ";
    cin >> id;
    // se encapsula la variable id 
    nod->setIdPadre(id);
    // se pide el nombre del padre o la madre del niño 
    cout << "Ingrese nombre del padre/madre del nino" << endl;
    cout << ">> ";
    cin >> n_p;
    // se encapsula la variable n_p 
    nod->setNombrePadre(n_p);
    // con el ciclo do while comprobare que se ingrese el municipio correcto 
    do
    {
        cout << "Ingrese municipio donde vive el nino" << endl;
        cout << "1. Sahagun" << endl;
        cout << "2. Monteria" << endl;
        cout << "3. Lorica" << endl;
        cout << ">> ";
        cin >> m;
        system("cls");
    }
    while (m < 1 || m > 3);
    // se encapsula la variable m 
    nod->setMunicipio(m);
}

// método para mostrar el municipio 
string mostrarMunicipio(int opc)
{
    // mediante el valor que se pase como parametro opc, el switch escore el caso 
    switch (opc)
    {
        case 1:
            return "Sahagun";
        case 2:
            return "Monteria";
        default:
            return "Lorica";
    }
}

// método para mostrar la informacion del niño 
void mostrar(Nino *nod)
{
    cout << "Nombre: " << nod->getNombre() << endl;
    cout << "Edad: " << nod->getEdad() << endl;
    cout << "Registro Civil: " << nod->getRegistroCivil() << endl;
    cout << "Altura: " << nod->getAltura() << endl;
    cout << "Peso: " << nod->getPeso() << endl;
    cout << "Nombre representante: " << nod->getNombrePadre() << endl;
    cout << "ID representante: " << nod->getIdPadre() << endl;
    cout << "Municipio: " << mostrarMunicipio(nod->getMunicipio()) << endl << endl;
}

// método para listar todos la lista 
void listar(ProgramaDepartamental *obj)
{
    // declaro e inicializo la variable temp en el valor que tenga la cabeza 
    Nino *temp = obj->getCabeza();
    // mientras haya un nodo en la lista 
    while (temp != NULL)
    {
        // entonces mostrara la informacion del nodo temp 
        mostrar(temp);
        // y se salta al siguiente nodo temp 
        temp = temp->getSiguiente();
    }
}

// método para listar los niños por municipio 
void listarPorMunicipio(ProgramaDepartamental *obj)
{
    // como son 3 municipios, entonces recorrere con el ciclo for desde 1 hasta 3 
    for (int i = 1; i <= 3; i++)
    {
        // muestro en un mensaje de dialogo, el municipio actual: mostrarMunicipio(i) 
        cout << "[Ninos del municipio de " << mostrarMunicipio(i) << "]" << endl;
        // declaro e inicializo la variable temp con el valor de la cabeza 
        Nino *temp = obj->getCabeza();
        // mientras haya un nodo en la lista 
        while (temp != NULL)
        {
            // entonces, si el nodo temp pertenece al municipio i (i = 0: Sahagún, i = 1: Montería, i = 2: Lorica) 
            if (temp->getMunicipio() == i)
            {
                // se muestra la información del nodo temp 
                mostrar(temp);
            }
            // se salta al siguiente nodo temporal 
            temp = temp->getSiguiente();
        }
        // muestro la cantidad de niños de cada municipio, llamando al metodo contarNiñosMunicipio y pasandole como parametro i 
        cout << "Hay " << obj->contarNinosMunicipio(i) << " nino(s) en el municipio de " << mostrarMunicipio(i) << endl;
    }
}

// método para listar cada niño si cumple las condiciones de peso bajo 
void listarPorCondicionesPeso(ProgramaDepartamental *obj)
{
    cout << "[Ninos de 2 y 3 o 4 y 6 años en condiciones de bajo peso]" << endl;
    // como son 3 municipios, entonces recorrere con el ciclo for desde 1 hasta 3 
    for (int i = 1; i <= 3; i++)
    {
        // declaro e inicializo la variable temp con el valor de la cabeza 
        Nino *temp = obj->getCabeza();
        // mientras haya un nodo en la lista 
        while (temp != NULL)
        {
            // entonces, si el municipio es igual a i, y tiene una edad entre 2 y 3 años y pesa menos de 15 kg ó si tiene una edad entre 4 y 6 y pesa menos de 25 kg 
            if (temp->getMunicipio() == i && ((temp->getEdad() >= 2 && temp->getEdad() <= 3) && temp->getPeso() < 15) || temp->getMunicipio() == i && ((temp->getEdad() >= 4 && temp->getEdad() <= 6) && temp->getPeso() < 25))
            {
                // se mostrara la informacion del nodo temp 
                mostrar(temp);
            }
            // se salta al siguiente nodo temp 
            temp = temp->getSiguiente();
        }
        // se muestra la cantidad de niños en condiciones de bajo peso por municipio 
        cout << "Hay " << obj->contarNinosMunicipioPeso(i) << " nino(s) en el municipio de " << mostrarMunicipio(i) << " en condiciones de bajo peso." << endl;
    }
}

// método para listar cada niño si tiene una altura menor a 1 metro 
void listarPorAltura(ProgramaDepartamental *obj)
{
    cout << "[Ninos entre 4 y 6 años que miden menos de 1 metro]" << endl;
    // como son 3 municipios, entonces recorrere con el ciclo for desde 1 hasta 3 
    for (int i = 1; i <= 3; i++)
    {
        // declaro e inicializo la variable temp con el valor de la cabeza 
        Nino *temp = obj->getCabeza();
        // mientras haya un nodo en la lista 
        while (temp != NULL)
        {
            // si el niño esta en el municipio i y tiene una edad entre 4 y 6 años y tiene una altura menor a 1 m 
            if (temp->getMunicipio() == i && ((temp->getEdad() >= 4 && temp->getEdad() <= 6) && temp->getAltura() < 1))
            {
                // entonces se mostrara la información del nodo temp 
                mostrar(temp);
            }
            // se salta al siguiente nodo temp 
            temp = temp->getSiguiente();
        }
        // se muestra la cantidad de niños con una estatura menor a 1m por municipio 
        cout << "Hay " << obj->contarNinosPorAltura(i) << " nino(s) en el municipio de " << mostrarMunicipio(i) << " en condiciones de bajo peso." << endl;
    }
}

// método para mostrar el menu de opciones 
int menu()
{
    int opc;
    do
    {
        cout << "1. Agregar informacion del nino y su representante por el final." << endl;
        cout << "2. Insertar entre dos nodos existentes." << endl;
        cout << "3. Agregar informacion del nino y su representante por el principio." << endl;
        cout << "4. Buscar por numero de registro civil." << endl;
        cout << "5. Ordenar la informacion, teniendo en cuenta el peso de los niños." << endl;
        cout << "6. Eliminar la informacion de un nino y su representante." << endl;
        cout << "7. Listado por municipios." << endl;
        cout << "8. Listado por condiciones bajos de peso." << endl;
        cout << "9. Listado por altura." << endl;
        cout << "10. Mostrar toda la lista." << endl;
        cout << "11. Salir" << endl;
        cout << ">> ";
        cin >> opc;
        system("cls");
    }
    while (opc < 0 || opc > 11);
    return opc;
}

int main(void)
{
    // creo un objeto de la clase ProgramaDepartamental (instanciación) 
    ProgramaDepartamental *obj = new ProgramaDepartamental();
    // declaro una variable de tipo Nino 
    Nino *aux;
    // declaro dos variables de tipo entero opcion y num_reg 
    int opcion, num_reg;
    do
    {
       // se le asigna a la variable opcion el valor que retorne el metodo menu 
       opcion = menu();
       // dependiendo del valor de la opcion se escogera un caso 
       switch(opcion)
       {
            case 1:
                aux = new Nino();
                llenar(aux);
                obj->agregarFinal(aux);
                cout << "Se ha agregado correctamente la información" << endl;
                break;
            case 2:
                cout << "Ingrese número de registro del nodo anterior al que desea agregar" << endl;
                cout << ">> ";
                cin >> num_reg;
                aux = obj->buscar(num_reg);
                if(aux != NULL)
                {
                    aux = new Nino();
                    llenar(aux);
                    obj->agregarEntreNodos(obj->buscar(num_reg), aux);
                    cout << "Se ha agregado correctamente la información" << endl;
                }
                else
                {
                    cout << "No se ha encontrado el nodo!" << endl;
                }
                break;
            case 3:
                aux = new Nino();
                llenar(aux);
                obj->agregarInicio(aux);
                cout << "Se ha agregado correctamente la información" << endl;
                break;
            case 4:
                cout << "Ingrese número de registro del nodo anterior al que desea agregar" << endl;
                cout << ">> ";
                cin >> num_reg;
                aux = obj->buscar(num_reg);
                if(aux != NULL)
                {
                    mostrar(obj->buscar(num_reg));
                }
                else
                {
                    cout << "No se ha encontrado el nodo!" << endl;
                }
                break;
            case 5:
                aux = obj->getCabeza();
                if (aux != NULL)
                {
                    if(obj->contarNodos() > 1)
                    {
                        aux = obj->getCabeza();
                        obj->ordenarIntercambio(aux);
                        listar(obj);
                    }
                    else
                    {
                        cout << "Solo hay un nino, agregue por lo menos 1 niño mas para ordenar." << endl;
                    }
                }
                break;
            case 6:
                aux = obj->getCabeza();
                obj->eliminarNodo(aux);
                cout << "Se elimino correctamente." << endl;
                break;
            case 7:
                listarPorMunicipio(obj);
                break;
            case 8:
                listarPorCondicionesPeso(obj);
                break;
            case 9:
                listarPorAltura(obj);
                break;
            case 10:
                listar(obj);
                break;
            default:
                break;
       }
    }
    while (opcion != 11);
}

#ifndef NINO_H
#define NINO_H
#include <iostream>

using namespace std;

class Nino
{
    public:
        Nino();
        virtual ~Nino();
        // metodos publicos de la clase Nino 
        void setEdad(int val);
        int getEdad();
        void setNombre(string val);
        string getNombre();
        void setRegistroCivil(int val);
        int getRegistroCivil();
        void setAltura(float val);
        float getAltura();
        void setPeso(int val);
        int getPeso();
        void setIdPadre(int val);
        int getIdPadre();
        void setNombrePadre(string val);
        string getNombrePadre();
        void setMunicipio(int val);
        int getMunicipio();
        void setSiguiente(Nino *val);
        Nino *getSiguiente();
        void setAnterior(Nino *val);
        Nino *getAnterior();
        void copiar(Nino *nd);

    protected:

    private:
        // atributos privados de la clase Nino 
        int edad;
        string nombre;
        int registro_civil;
        float altura;
        int peso;
        int id_padre;
        string nombre_padre;
        int municipio;
        Nino *siguiente;
        Nino *anterior;
};

#endif // NINO_H 

#include "Nino.h"

Nino::Nino()
{
    // se le asigna valores por defecto en el constructor a los atributos de la clase Nino 
    edad = 0;
    nombre = "";
    registro_civil = 0;
    altura = 0;
    peso = 0;
    id_padre = 0;
    nombre_padre = "";
    municipio = 0;
    siguiente = NULL;
    anterior = NULL;
}

Nino::~Nino()
{
    //dtor 
}

// metodos Setters y Getters de los atributos de la clase 
void Nino::setEdad(int val)
{
    edad = val;
}

int Nino::getEdad()
{
    return edad;
}

void Nino::setNombre(string val)
{
    nombre = val;
}

string Nino::getNombre()
{
    return nombre;
}

void Nino::setRegistroCivil(int val)
{
    registro_civil = val;
}

int Nino::getRegistroCivil()
{
    return registro_civil;
}

void Nino::setAltura(float val)
{
    altura = val;
}

float Nino::getAltura()
{
    return altura;
}

void Nino::setPeso(int val)
{
    peso = val;
}

int Nino::getPeso()
{
    return peso;
}

void Nino::setIdPadre(int val)
{
    id_padre = val;
}

int Nino::getIdPadre()
{
    return id_padre;
}

void Nino::setNombrePadre(string val)
{
    nombre_padre = val;
}

string Nino::getNombrePadre()
{
    return nombre_padre;
}

void Nino::setMunicipio(int val)
{
    municipio = val;
}

int Nino::getMunicipio()
{
    return municipio;
}

void Nino::setSiguiente(Nino *val)
{
    siguiente = val;
}

Nino *Nino::getSiguiente()
{
    return siguiente;
}

void Nino::setAnterior(Nino *val)
{
    anterior = val;
}

Nino *Nino::getAnterior()
{
    return anterior;
}

// método para copiar toda la información de un nodo 
void Nino::copiar(Nino *nd)
{
    edad = nd->getEdad();
    nombre = nd->getNombre();
    registro_civil = nd->getRegistroCivil();
    altura = nd->getAltura();
    peso = nd->getPeso();
    id_padre = nd->getIdPadre();
    nombre_padre = nd->getNombrePadre();
}

#ifndef PROGRAMADEPARTAMENTAL_H
#define PROGRAMADEPARTAMENTAL_H
#include "Nino.h"
#include <iostream>

using namespace std;

class ProgramaDepartamental
{
    public:
        ProgramaDepartamental();
        virtual ~ProgramaDepartamental();
        // metodos publicos de la clase ProgramaDepartamental 
        void setCabeza(Nino *val);
        Nino *getCabeza();
        Nino *ultimo();
        void agregarFinal(Nino *nuevo);
        void agregarEntreNodos(Nino *nd, Nino *nuevo);
        void agregarInicio(Nino *nuevo);
        void eliminarNodo(Nino *nd);
        Nino *buscar(int num_r);
        int contarNodos();
        int contarNinosMunicipio(int mun);
        int contarNinosMunicipioPeso(int mun);
        int contarNinosPorAltura(int mun);
        void ordenarIntercambio(Nino *n);
        void cambiar(Nino *p1, Nino *p2);
    protected:

    private:
        // atributo privado de la clase ProgramaDepartamental 
        Nino *cabeza;
};

#endif // PROGRAMADEPARTAMENTAL_H 

#include "ProgramaDepartamental.h"

ProgramaDepartamental::ProgramaDepartamental()
{
    // se le asigna un valor por defecto en el contructor al atributo de la clase ProgramaDepartamental 
    cabeza = NULL;
}

ProgramaDepartamental::~ProgramaDepartamental()
{
    //dtor 
}

// metodo set y get del atributo de la clase 
void ProgramaDepartamental::setCabeza(Nino *val)
{
    cabeza = val;
}

Nino* ProgramaDepartamental::getCabeza()
{
    return cabeza;
}

// método para retornar el ultimo nodo de la lista 
Nino* ProgramaDepartamental::ultimo()
{
    // se inicializa una variable de tipo Nino en la cabeza 
    Nino *temp = cabeza;
    // mientras haya un nodo en la lista 
    while(temp != NULL)
    {
        // entonces, si el siguiente nodo de temp es igual a null 
        if (temp->getSiguiente() == NULL)
        {
            // entonces, se rompe el ciclo 
            break;
        }
        else
        {
            // sino, se salta al siguiente nodo del temp 
            temp = temp->getSiguiente();
        }
    }
    // se retorna el nodo temp 
    return temp;
}

// método para agregar por el final 
void ProgramaDepartamental::agregarFinal(Nino *nuevo)
{
    // se inicializa una variable de tipo Nino en el valor que retorne el metodo ultimo 
    Nino *temp = ultimo();
    // si la cabeza es diferente a null (si hay un nodo en la lista) 
    if (cabeza != NULL)
    {
        // entonces, el siguiente nodo de temp ahora sera el nuevo nodo 
        temp->setSiguiente(nuevo);
        // el nodo anterior de nuevo ahora sera el nodo temp 
        nuevo->setAnterior(temp);
        // y el siguiente de nodo ahora sera null 
        nuevo->setSiguiente(NULL);
    }
    else
    {
        // sino, entonces la cabeza apuntara al nuevo nuevo 
        cabeza = nuevo;
        // y el siguiente de nodo ahora sera null 
        nuevo->setAnterior(NULL);
    }
}

// método para agregar entre nodos 
void ProgramaDepartamental::agregarEntreNodos(Nino *nd, Nino *nuevo)
{
    // el siguiente nodo del nuevo sera el siguiente nodo de nd 
    nuevo->setSiguiente(nd->getSiguiente());
    // si el siguiente nodo de nd es diferente a null 
    if (nd->getSiguiente() != NULL)
    {
        // entonces el nodo anterior del siguiente nodo de nd ahora sera el nuevo nodo 
        nd->getSiguiente()->setAnterior(nuevo);
    }
    // el siguiente nodo de nd sera el nuevo nodo 
    nd->setSiguiente(nuevo);
    // el nodo anterior del nuevo nodo ahora sera el nodo nd 
    nuevo->setAnterior(nd);
}

// método para agregar desde el inicio 
void ProgramaDepartamental::agregarInicio(Nino *nuevo)
{
    // si la cabeza es diferente a null 
    if (cabeza != NULL)
    {
        // entonces, el siguiente nodo del nuevo ahora sera la cabeza 
        nuevo->setSiguiente(cabeza);
        // el nodo anterior de la cabeza sera el nuevo nodo 
        cabeza->setAnterior(nuevo);
        // el nodo anterior del nuevo nodo sera null 
        nuevo->setAnterior(NULL);
        // la cabeza sera el nuevo nodo 
        setCabeza(nuevo);
    }
    else
    {
        // sino, la cabeza sera el nuevo nodo 
        cabeza = nuevo;
        // el nodo anterior del nuevo nodo apuntara a null 
        nuevo->setAnterior(NULL);
    }
}

// método para eliminar nodo 
void ProgramaDepartamental::eliminarNodo(Nino *nd)
{
    // se declara una variable de tipo Nino llamada anterior 
    Nino *anterior;
    // si el nodo nd es igual a la cabeza 
    if (nd == cabeza)
    {
        // entonces, la cabeza saltara a su siguiente (saltaria a null) 
        cabeza = cabeza->getSiguiente();
    }
    else
    {
        // sino, el nodo anterior tendra el valor de la cabeza 
        anterior = cabeza;
        // mientras el siguiente nodo del anterior sea difente al nodo nd 
        while (anterior->getSiguiente() != nd)
        {
            // entonces se salta al siguiente nodo del anterior 
            anterior = anterior->getSiguiente();
        }
        // el siguiente del anterior ahora sera el siguiente nodo de nd 
        anterior->setSiguiente(nd->getSiguiente());
        // el anterior del siguiente nodo de nd ahora sera el nodo anterior 
        nd->getSiguiente()->setAnterior(anterior);
    }
    // el siguiente de nd sera null 
    nd->setSiguiente(NULL);
    // el anterior de nd sera null 
    nd->setAnterior(NULL);
}

// método para buscar mediante el numero de registro 
Nino* ProgramaDepartamental::buscar(int num_r)
{
    // se declara una variable de tipo Nino 
    Nino *temp;
    // se le asigna a temp el valor de la cabeza 
    temp = cabeza;
    // mientras haya un nodo en la lista 
    while(temp != NULL)
    {
        // entonces, si el registro civil del nodo temp es igual al valor de la variable num_r 
        if (temp->getRegistroCivil() == num_r)
        {
            // se rompe el ciclo 
            break;
        }
        else
        {
            // sino, se salta al siguiente nodo de temp 
            temp = temp->getSiguiente();
        }
    }
    // se retorna el nodo temp 
    return temp;
}

// método para contar los nodos de la lista 
int ProgramaDepartamental::contarNodos()
{
    // se inicializa la variable de tipo Nino temp en la cabeza 
    Nino *temp = cabeza;
    // se inicializa la variable de tipo entero contador en 0 
    int contador = 0;
    // mientras haya un nodo en la lista 
    while(temp != NULL)
    {
        // se incrementara la variable contador 
        contador++;
        // y se salta al siguiente nodo de temp 
        temp = temp->getSiguiente();
    }
    // se retorna el valor de la variable contador 
    return contador;
}

// método para contar los niños de cada municipio 
int ProgramaDepartamental::contarNinosMunicipio(int mun)
{
    // se inicializa la variable de tipo Nino temp en la cabeza 
    Nino *temp = cabeza;
    // se inicializa la variable de tipo entero contador en 0 
    int contador = 0;
    // mientras haya un nodo en la lista 
    while(temp != NULL)
    {
        // si el municipio del nodo temp es igual al valor de la variable mun 
        if (temp->getMunicipio() == mun)
        {
            // se incrementa el valor de la variable contador 
            contador++;
        }
        // se salta al siguiente nodo de temp 
        temp = temp->getSiguiente();
    }
    // se retorna el valor de la variable contador 
    return contador;
}

// método para contar los niños de cada municipio en condiciones de bajo peso 
int ProgramaDepartamental::contarNinosMunicipioPeso(int mun)
{
    // se inicializa la variable de tipo Nino temp en la cabeza 
    Nino *temp = cabeza;
    // se inicializa la variable de tipo entero contador en 0 
    int contador = 0;
    // mientras haya un nodo en la lista 
    while(temp != NULL)
    {
        // si el municipio del nodo temp es igual al valor de la variable mun y esta entre el rango de 2 a 3 años y tiene un peso menor a 15 kg
        // ó si el municipio del nodo temp es igual al valor de la variable num y esta tiene una edad entre 4 y 6 años y tiene un peso inferior a 25kg 
        if (temp->getMunicipio() == mun && ((temp->getEdad() >= 2 && temp->getEdad() <= 3) && temp->getPeso() < 15) || temp->getMunicipio() == mun && ((temp->getEdad() >= 4 && temp->getEdad() <= 6) && temp->getPeso() < 25))
        {
            // se incrementa el valor de la variable contador 
            contador++;
        }
        // se salta al siguiente nodo de temp 
        temp = temp->getSiguiente();
    }
    // se retorna el valor de la variable contador 
    return contador;
}

// método para contar la cantidad de niños que tienen una altura inferiro a 1m 
int ProgramaDepartamental::contarNinosPorAltura(int mun)
{
    // se inicializa la variable de tipo Nino temp en la cabeza 
    Nino *temp = cabeza;
    // se inicializa la variable de tipo entero contador en 0 
    int contador = 0;
    // mientras haya un nodo en la lista 
    while(temp != NULL)
    {
        // si el municipio del nodo temp es igual al valor de la variable num y si tiene una edad entre 4 y 6 años
        // y si tiene una altura menor a 1 
        if (temp->getMunicipio() == mun && ((temp->getEdad() >= 4 && temp->getEdad() <= 6) && temp->getAltura() < 1))
        {
            // se incrementa el valor de la variable contador 
            contador++;
        }
        // se salta al siguiente nodo de temp 
        temp = temp->getSiguiente();
    }
    // se retorna el valor de la variable contador 
    return contador;
}

// método para ordenar por intercambio 
void ProgramaDepartamental::ordenarIntercambio(Nino *n)
{
    // Se declaran dos variables de tipo Nino actual y siguiente 
    Nino *actual;
    Nino *siguiente;
    // se le asigna al nodo actual el valor del nodo n 
    actual = n;
    // mientras el siguiente nodo del actual sea diferente a null 
    while(actual->getSiguiente() != NULL)
    {
        // entonces, se le asignara al nodo siguiente el valor del siguiente nodo del actual 
        siguiente = actual->getSiguiente();
        // mientra el nodo siguiente sea diferente a null 
        while(siguiente != NULL)
        {
            // entonces si el peso del nodo actual es mayor al peso del siguiente nodo 
            if(actual->getPeso() > siguiente->getPeso())
            {
                // entonces se cambia el nodo actual por el siguiente 
                cambiar(actual, siguiente);
            }
            // se salta al siguiente nodo de siguiente 
            siguiente = siguiente->getSiguiente();
        }
        // se salta al siguiente nodo de actual 
        actual = actual->getSiguiente();
    }
}

// método para cambiar los nodos 
void ProgramaDepartamental::cambiar(Nino* p1, Nino* p2)
{
    // creo un nuevo nodo para poder realizar la copia 
    Nino *temp = new Nino();
    // le asigno al nodo temp los datos del nodo actual (p1) 
    temp->copiar(p1);
    // le asigno al nodo p1 los datos del nodo siguiente (p2) 
    p1->copiar(p2);
    // le asigno al nodo p2 los datos del temp 
    p2->copiar(temp);
}

// se importa paquete JOptionPane para dibujar un cuadro de dialogo en pantalla
// que muestre información o para llenar información 
import javax.swing.JOptionPane;

public class Main
{
    // método para llenar la lista 
    public static void llenar(Niño nod)
    {
        int e;
        // con el ciclo do while comprobare que la edad este entre el rango de 1 y 6 años 
        do
        {
            e = Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese edad del niño:")); 
        }
        while (e < 1 || e > 6);
        // encapsulo la variable e 
        nod.setEdad(e); 
        // se pide el nombre del niño 
        String n = JOptionPane.showInputDialog(null,"Ingrese nombre del niño:");
        // encapsulo la variable n 
        nod.setNombre(n);
        // se pide el registro civil del niño 
        int n_r = Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese número de registro civil del niño:")); 
        // encapsulo la variable n_r 
        nod.setRegistroCivil(n_r);
        // se pide la altura del niño 
        float a = Float.parseFloat(JOptionPane.showInputDialog(null,"Ingrese altura del niño:")); 
        // se encapsula la variable a 
        nod.setAltura(a);
        // se pide el peso del niño 
        int p = Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese peso del niño:"));
        // se encapsula la variable p 
        nod.setPeso(p);
        // se pide el numero de identificacion del padre 
        int id = Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese número de identificación del padre/madre del niño:"));
        // se encapsula la variable id 
        nod.setIdPadre(id);
        // se pide el nombre del padre o la madre del niño 
        String n_p = JOptionPane.showInputDialog(null,"Ingrese nombre del padre/madre del niño:"); 
        // se encapsula la variable n_p 
        nod.setNombrePadre(n_p);
        int m;
        // con el ciclo do while comprobare que se ingrese el municipio correcto 
        do
        {
            m = Integer.parseInt(JOptionPane.showInputDialog(null,
                "Ingrese municipio donde vive el niño\n" +
                "1. Sahagún\n" +
                "2. Montería\n" +
                "3. Lorica\n"));
        }
        while (m < 1 || m > 3);
        // se encapsula la variable m 
        nod.setMunicipio(m);
    }
    
    // método para mostrar el municipio 
    public static String mostrarMunicipio(int opc)
    {
        // mediante el valor que se pase como parametro opc, el switch escore el caso 
        switch (opc)
        {
            case 1:
                return "Sahagún";
            case 2:
                return "Montería";
            default:
                return "Lorica";
        }
    }
    
    // método para mostrar la informacion del niño 
    public static void mostrar(Niño nod)
    {
        // declaro una variable de tipo String datos y la inicializo en "" 
        String datos = ""; 
        // le acumulo a la variable datos los valores convertidos a String del niño 
        datos += String.valueOf(
                "Nombre: " + nod.getNombre() + "\n" +
                "Edad: " + nod.getEdad() + "\n" +
                "Registro Civil: " + nod.getRegistroCivil() + "\n" +
                "Altura: " + nod.getAltura() + "\n" +
                "Peso: " + nod.getPeso() + "\n" +
                "Nombre representante: " + nod.getNombrePadre() + "\n" +
                "ID representante: " + nod.getIdPadre() + "\n" +
                "Municipio: " + mostrarMunicipio(nod.getMunicipio()) + "\n\n");
        // muestro con mensaje de dialogo la variable datos 
        JOptionPane.showMessageDialog(null,datos); 
    } 
    
    // método para listar todos la lista 
    public static void listar(ProgramaDepartamental obj)
    {
        // declaro e inicializo la variable temp en el valor que tenga la cabeza 
        Niño temp = obj.getCabeza(); 
        // mientras haya un nodo en la lista 
        while (temp != null)
        {
            // entonces mostrara la informacion del nodo temp 
            mostrar(temp);
            // y se salta al siguiente nodo temp 
            temp = temp.getSiguiente();
        }
    }
    
    // método para listar los niños por municipio 
    public static void listarPorMunicipio(ProgramaDepartamental obj)
    {
        // como son 3 municipios, entonces recorrere con el ciclo for desde 1 hasta 3 
        for (int i = 1; i <= 3; i++)
        {
            // muestro en un mensaje de dialogo, el municipio actual: mostrarMunicipio(i) 
            JOptionPane.showMessageDialog(null, "[Niños del municipio de " + mostrarMunicipio(i) + "]");
            // declaro e inicializo la variable temp con el valor de la cabeza 
            Niño temp = obj.getCabeza();
            // mientras haya un nodo en la lista 
            while (temp != null)
            {
                // entonces, si el nodo temp pertenece al municipio i (i = 0: Sahagún, i = 1: Montería, i = 2: Lorica) 
                if (temp.getMunicipio() == i)
                {
                    // se muestra la información del nodo temp 
                    mostrar(temp);
                }
                // se salta al siguiente nodo temporal 
                temp = temp.getSiguiente();
            }
            // muestro la cantidad de niños de cada municipio, llamando al metodo contarNiñosMunicipio y pasandole como parametro i 
            JOptionPane.showMessageDialog(null, "Hay " + obj.contarNiñosMunicipio(i) + " niño(s) en el municipio de " + mostrarMunicipio(i));
        }
    }
    
    // método para listar cada niño si cumple las condiciones de peso bajo 
    public static void listarPorCondicionesPeso(ProgramaDepartamental obj)
    {
        JOptionPane.showMessageDialog(null, "[Niños de 2 y 3 o 4 y 6 años en condiciones de bajo peso]");
        // como son 3 municipios, entonces recorrere con el ciclo for desde 1 hasta 3 
        for (int i = 1; i <= 3; i++)
        {
            // declaro e inicializo la variable temp con el valor de la cabeza 
            Niño temp = obj.getCabeza();
            // mientras haya un nodo en la lista 
            while (temp != null)
            {
                // entonces, si el municipio es igual a i, y tiene una edad entre 2 y 3 años y pesa menos de 15 kg ó si tiene una edad entre 4 y 6 y pesa menos de 25 kg 
                if (temp.getMunicipio() == i && ((temp.getEdad() >= 2 && temp.getEdad() <= 3) && temp.getPeso() < 15) || temp.getMunicipio() == i && ((temp.getEdad() >= 4 && temp.getEdad() <= 6) && temp.getPeso() < 25))
                {
                    // se mostrara la informacion del nodo temp 
                    mostrar(temp);
                }
                // se salta al siguiente nodo temp 
                temp = temp.getSiguiente();
            }
            // se muestra la cantidad de niños en condiciones de bajo peso por municipio 
            JOptionPane.showMessageDialog(null, "Hay " + obj.contarNiñosMunicipioPeso(i) + " niño(s) en el municipio de " + mostrarMunicipio(i) + " en condiciones de bajo peso.");
        }
    }
    
    // método para listar cada niño si tiene una altura menor a 1 metro 
    public static void listarPorAltura(ProgramaDepartamental obj)
    {
        JOptionPane.showMessageDialog(null, "[Niños entre 4 y 6 años que miden menos de 1 metro]");
        // como son 3 municipios, entonces recorrere con el ciclo for desde 1 hasta 3 
        for (int i = 1; i <= 3; i++)
        {
            // declaro e inicializo la variable temp con el valor de la cabeza 
            Niño temp = obj.getCabeza();
            // mientras haya un nodo en la lista 
            while (temp != null)
            {
                // si el niño esta en el municipio i y tiene una edad entre 4 y 6 años y tiene una altura menor a 1 m 
                if (temp.getMunicipio() == i && ((temp.getEdad() >= 4 && temp.getEdad() <= 6) && temp.getAltura() < 1))
                {
                    // entonces se mostrara la información del nodo temp 
                    mostrar(temp);
                }
                // se salta al siguiente nodo temp 
                temp = temp.getSiguiente();
            }
            // se muestra la cantidad de niños con una estatura menor a 1m por municipio 
            JOptionPane.showMessageDialog(null, "Hay " + obj.contarNiñosPorAltura(i) + " niño(s) en el municipio de " + mostrarMunicipio(i) + " en condiciones de bajo peso.");
        }
    }
    
    // método para mostrar el menu de opciones 
    public static int menu()
    { 
        int opc; 
        do
        {
            opc = Integer.parseInt(JOptionPane.showInputDialog(null,
                "==================MENU==================\n" +
                "1. Agregar información del niño y su representante por el final.\n" +
                "2. Insertar entre dos nodos existentes.\n" +
                "3. Agregar información del niño y su representante por el principio.\n" +
                "4. Buscar por número de registro civil.\n" +
                "5. Ordenar la información, teniendo en cuenta el peso de los niños.\n" +
                "6. Eliminar la información de un niño y su representante.\n" +
                "7. Listado por municipios.\n" +
                "8. Listado por condiciones bajos de peso.\n" +
                "9. Listado por altura.\n" +
                "10. Mostrar toda la lista\n" +
                "11. Salir")); 
        }
        while (opc < 0 || opc > 11);
        return opc; 
    } 
    
    public static void main(String[] args)
    {
        // creo un objeto de la clase ProgramaDepartamental (instanciación) 
        ProgramaDepartamental obj = new ProgramaDepartamental();
        // declaro una variable de tipo Niño 
        Niño aux;
        // declaro dos variables de tipo entero opcion y num_reg 
        int opcion, num_reg;
        do
        { 
           // se le asigna a la variable opcion el valor que retorne el metodo menu 
           opcion = menu();
           // dependiendo del valor de la opcion se escogera un caso 
           switch(opcion)
           {
                case 1:
                    aux = new Niño();
                    llenar(aux);
                    obj.agregarFinal(aux);
                    JOptionPane.showMessageDialog(null,"Se ha agregado correctamente la información");
                    break;
                case 2:
                    num_reg = Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese número de registro del nodo anterior al que desea agregar:")); 
                    aux = obj.buscar(num_reg);
                    if(aux != null)
                    {
                        aux = new Niño(); 
                        llenar(aux);
                        obj.agregarEntreNodos(obj.buscar(num_reg), aux); 
                        JOptionPane.showMessageDialog(null,"Se ha agregado correctamente la información");
                    }
                    else
                    {
                        JOptionPane.showMessageDialog(null,"No se ha encontrado el nodo!"); 
                    }
                    break;
                case 3:
                    aux = new Niño();
                    llenar(aux);
                    obj.agregarInicio(aux);
                    JOptionPane.showMessageDialog(null,"Se ha agregado correctamente la información");
                    break;
                case 4:
                    num_reg = Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese número de registro del nodo anterior al que desea agregar:")); 
                    aux = obj.buscar(num_reg);
                    if(aux != null)
                    {
                        mostrar(obj.buscar(num_reg)); 
                    }
                    else
                    {
                        JOptionPane.showMessageDialog(null,"No se ha encontrado el nodo!"); 
                    }
                    break;
                case 5:
                    aux = obj.getCabeza();
                    if (aux != null)
                    {
                        if(obj.contarNodos() > 1)
                        {
                            aux = obj.getCabeza();
                            obj.ordenarIntercambio(aux);
                            listar(obj);
                        }
                        else
                        {
                            JOptionPane.showMessageDialog(null, "Solo hay un niño, agregue por lo menos 1 niño mas para ordenar.");
                        }
                    }
                    break;
                case 6:
                    aux = obj.getCabeza();
                    obj.eliminarNodo(aux);
                    JOptionPane.showMessageDialog(null, "Se elimino correctamente.");
                    break;
                case 7:
                    listarPorMunicipio(obj);
                    break;
                case 8:
                    listarPorCondicionesPeso(obj);
                    break;
                case 9:
                    listarPorAltura(obj);
                    break;
                case 10:
                    listar(obj);
                    break;
                default:
                    break;
           } 
        }
        while (opcion != 11);
    }
}

public class Niño
{
    // atributos privados de la clase Niño 
    private int edad;
    private String nombre;
    private int registro_civil;
    private float altura;
    private int peso;
    private int id_padre;
    private String nombre_padre;
    private int municipio;
    private Niño siguiente;
    private Niño anterior;
    
    public Niño()
    {
        // se le asigna valores por defecto en el constructor a los atributos de la clase Niño 
        edad = 0;
        nombre = "";
        registro_civil = 0;
        altura = 0;
        peso = 0;
        id_padre = 0;
        nombre_padre = "";
        municipio = 0;
        siguiente = null;
        anterior = null;
    }
    
    // metodos Setters y Getters de los atributos de la clase 
    public void setEdad(int val)
    {
        edad = val;
    }
    
    public int getEdad()
    {
        return edad;
    }
    
    public void setNombre(String val)
    {
        nombre = val;
    }
    
    public String getNombre()
    {
        return nombre;
    }
    
    public void setRegistroCivil(int val)
    {
        registro_civil = val;
    }
    
    public int getRegistroCivil()
    {
        return registro_civil;
    }
    
    public void setAltura(float val)
    {
        altura = val;
    }
    
    public float getAltura()
    {
        return altura;
    }
    
    public void setPeso(int val)
    {
        peso = val;
    }
    
    public int getPeso()
    {
        return peso;
    }
    
    public void setIdPadre(int val)
    {
        id_padre = val;
    }
    
    public int getIdPadre()
    {
        return id_padre;
    }
    
    public void setNombrePadre(String val)
    {
        nombre_padre = val;
    }
    
    public String getNombrePadre()
    {
        return nombre_padre;
    }
    
    public void setMunicipio(int val)
    {
        municipio = val;
    }
    
    public int getMunicipio()
    {
        return municipio;
    }
    
    public void setSiguiente(Niño val)
    {
        siguiente = val;
    }
    
    public Niño getSiguiente()
    {
        return siguiente;
    }
    
    public void setAnterior(Niño val)
    {
        anterior = val;
    }
    
    public Niño getAnterior()
    {
        return anterior;
    }
    
    // método para copiar toda la información de un nodo 
    public void copiar(Niño nd)
    {
        edad = nd.getEdad();
        nombre = nd.getNombre();
        registro_civil = nd.getRegistroCivil();
        altura = nd.getAltura();
        peso = nd.getPeso();
        id_padre = nd.getIdPadre();
        nombre_padre = nd.getNombrePadre();
    }
}

public class ProgramaDepartamental
{
    // se declara el atributo privado de la clase 
    private Niño cabeza;
    
    public ProgramaDepartamental()
    {
        // se le asigna un valor por defecto en el contructor al atributo de la clase ProgramaDepartamental 
        cabeza = null;
    }
    
    // metodo set y get del atributo de la clase 
    public void setCabeza(Niño val)
    {
        cabeza = val;
    }
    
    public Niño getCabeza()
    {
        return cabeza;
    }
    
    // método para retornar el ultimo nodo de la lista 
    public Niño ultimo()
    {
        // se inicializa una variable de tipo Niño en la cabeza 
        Niño temp = cabeza;
        // mientras haya un nodo en la lista 
        while(temp != null)
        {
            // entonces, si el siguiente nodo de temp es igual a null 
            if (temp.getSiguiente() == null)
            {
                // entonces, se rompe el ciclo 
                break; 
            }
            else
            {
                // sino, se salta al siguiente nodo del temp 
                temp = temp.getSiguiente(); 
            }
        }
        // se retorna el nodo temp 
        return temp; 
    }
    
    // método para agregar por el final 
    public void agregarFinal(Niño nuevo)
    { 
        // se inicializa una variable de tipo Niño en el valor que retorne el metodo ultimo 
        Niño temp = ultimo();
        // si la cabeza es diferente a null (si hay un nodo en la lista) 
        if (cabeza != null)
        {
            // entonces, el siguiente nodo de temp ahora sera el nuevo nodo 
            temp.setSiguiente(nuevo);
            // el nodo anterior de nuevo ahora sera el nodo temp 
            nuevo.setAnterior(temp);
            // y el siguiente de nodo ahora sera null 
            nuevo.setSiguiente(null);
        }
        else
        {
            // sino, entonces la cabeza apuntara al nuevo nuevo 
            cabeza = nuevo;
            // y el siguiente de nodo ahora sera null 
            nuevo.setAnterior(null); 
        }
    }
    
    // método para agregar entre nodos 
    public void agregarEntreNodos(Niño nd, Niño nuevo)
    {
        // el siguiente nodo del nuevo sera el siguiente nodo de nd 
        nuevo.setSiguiente(nd.getSiguiente()); 
        // si el siguiente nodo de nd es diferente a null 
        if (nd.getSiguiente() != null)
        {
            // entonces el nodo anterior del siguiente nodo de nd ahora sera el nuevo nodo 
            nd.getSiguiente().setAnterior(nuevo);
        }
        // el siguiente nodo de nd sera el nuevo nodo 
        nd.setSiguiente(nuevo);
        // el nodo anterior del nuevo nodo ahora sera el nodo nd 
        nuevo.setAnterior(nd);       
    }
    
    // método para agregar desde el inicio 
    public void agregarInicio(Niño nuevo)
    {
        // si la cabeza es diferente a null 
        if (cabeza != null)
        {
            // entonces, el siguiente nodo del nuevo ahora sera la cabeza 
            nuevo.setSiguiente(cabeza);
            // el nodo anterior de la cabeza sera el nuevo nodo 
            cabeza.setAnterior(nuevo); 
            // el nodo anterior del nuevo nodo sera null 
            nuevo.setAnterior(null);
            // la cabeza sera el nuevo nodo 
            setCabeza(nuevo);
        }
        else
        {
            // sino, la cabeza sera el nuevo nodo 
            cabeza = nuevo; 
            // el nodo anterior del nuevo nodo apuntara a null 
            nuevo.setAnterior(null);
        }
    }
    
    // método para eliminar nodo 
    public void eliminarNodo(Niño nd)
    {
        // se declara una variable de tipo Niño llamada anterior 
        Niño anterior;
        // si el nodo nd es igual a la cabeza 
        if (nd == cabeza)
        {
            // entonces, la cabeza saltara a su siguiente (saltaria a null) 
            cabeza = cabeza.getSiguiente(); 
        }
        else
        {
            // sino, el nodo anterior tendra el valor de la cabeza 
            anterior = cabeza;
            // mientras el siguiente nodo del anterior sea difente al nodo nd 
            while (anterior.getSiguiente() != nd)
            {
                // entonces se salta al siguiente nodo del anterior 
                anterior = anterior.getSiguiente(); 
            }
            // el siguiente del anterior ahora sera el siguiente nodo de nd 
            anterior.setSiguiente(nd.getSiguiente());
            // el anterior del siguiente nodo de nd ahora sera el nodo anterior 
            nd.getSiguiente().setAnterior(anterior); 
        }
        // el siguiente de nd sera null 
        nd.setSiguiente(null);
        // el anterior de nd sera null 
        nd.setAnterior(null);
    }
    
    // método para buscar mediante el numero de registro 
    public Niño buscar(int num_r)
    {
        // se declara una variable de tipo Niño 
        Niño temp;
        // se le asigna a temp el valor de la cabeza 
        temp = cabeza;
        // mientras haya un nodo en la lista 
        while(temp != null)
        {
            // entonces, si el registro civil del nodo temp es igual al valor de la variable num_r 
            if (temp.getRegistroCivil() == num_r)
            {
                // se rompe el ciclo 
                break; 
            }
            else
            {
                // sino, se salta al siguiente nodo de temp 
                temp = temp.getSiguiente(); 
            }
        }
        // se retorna el nodo temp 
        return temp; 
    } 
    
    // método para contar los nodos de la lista 
    public int contarNodos()
    {
        // se inicializa la variable de tipo Niño temp en la cabeza 
        Niño temp = cabeza;
        // se inicializa la variable de tipo entero contador en 0 
        int contador = 0;
        // mientras haya un nodo en la lista 
        while(temp != null)
        {
            // se incrementara la variable contador 
            contador++;
            // y se salta al siguiente nodo de temp 
            temp = temp.getSiguiente();
        }
        // se retorna el valor de la variable contador 
        return contador;
    }
    
    // método para contar los niños de cada municipio 
    public int contarNiñosMunicipio(int mun)
    {
        // se inicializa la variable de tipo Niño temp en la cabeza 
        Niño temp = cabeza;
        // se inicializa la variable de tipo entero contador en 0 
        int contador = 0;
        // mientras haya un nodo en la lista 
        while(temp != null)
        {
            // si el municipio del nodo temp es igual al valor de la variable mun 
            if (temp.getMunicipio() == mun)
            {
                // se incrementa el valor de la variable contador 
                contador++;
            }
            // se salta al siguiente nodo de temp 
            temp = temp.getSiguiente();
        }
        // se retorna el valor de la variable contador 
        return contador;
    }
    
    // método para contar los niños de cada municipio en condiciones de bajo peso 
    public int contarNiñosMunicipioPeso(int mun)
    {
        // se inicializa la variable de tipo Niño temp en la cabeza 
        Niño temp = cabeza;
        // se inicializa la variable de tipo entero contador en 0 
        int contador = 0;
        // mientras haya un nodo en la lista 
        while(temp != null)
        {
            // si el municipio del nodo temp es igual al valor de la variable mun y esta entre el rango de 2 a 3 años y tiene un peso menor a 15 kg
            // ó si el municipio del nodo temp es igual al valor de la variable num y esta tiene una edad entre 4 y 6 años y tiene un peso inferior a 25kg 
            if (temp.getMunicipio() == mun && ((temp.getEdad() >= 2 && temp.getEdad() <= 3) && temp.getPeso() < 15) || temp.getMunicipio() == mun && ((temp.getEdad() >= 4 && temp.getEdad() <= 6) && temp.getPeso() < 25))
            {
                // se incrementa el valor de la variable contador 
                contador++;
            }
            // se salta al siguiente nodo de temp 
            temp = temp.getSiguiente();
        }
        // se retorna el valor de la variable contador 
        return contador;
    }
    
    // método para contar la cantidad de niños que tienen una altura inferiro a 1m 
    public int contarNiñosPorAltura(int mun)
    {
        // se inicializa la variable de tipo Niño temp en la cabeza 
        Niño temp = cabeza;
        // se inicializa la variable de tipo entero contador en 0 
        int contador = 0;
        // mientras haya un nodo en la lista 
        while(temp != null)
        {
            // si el municipio del nodo temp es igual al valor de la variable num y si tiene una edad entre 4 y 6 años
            // y si tiene una altura menor a 1 
            if (temp.getMunicipio() == mun && ((temp.getEdad() >= 4 && temp.getEdad() <= 6) && temp.getAltura() < 1))
            {
                // se incrementa el valor de la variable contador 
                contador++;
            }
            // se salta al siguiente nodo de temp 
            temp = temp.getSiguiente();
        }
        // se retorna el valor de la variable contador 
        return contador;
    }
    
    // método para ordenar por intercambio 
    public void ordenarIntercambio(Niño n)
    {
        // Se declaran dos variables de tipo Niño actual y siguiente 
        Niño actual, siguiente;
        // se le asigna al nodo actual el valor del nodo n 
        actual = n;
        // mientras el siguiente nodo del actual sea diferente a null 
        while(actual.getSiguiente() != null)
        {
            // entonces, se le asignara al nodo siguiente el valor del siguiente nodo del actual 
            siguiente = actual.getSiguiente();
            // mientra el nodo siguiente sea diferente a null 
            while(siguiente != null)
            {
                // entonces si el peso del nodo actual es mayor al peso del siguiente nodo 
                if(actual.getPeso() > siguiente.getPeso())
                {
                    // entonces se cambia el nodo actual por el siguiente 
                    cambiar(actual, siguiente);
                }
                / se salta al siguiente nodo de siguiente 
                siguiente = siguiente.getSiguiente();
            }
            // se salta al siguiente nodo de actual 
            actual = actual.getSiguiente();
        }
    }
    
    // método para cambiar los nodos 
    public void cambiar(Niño p1, Niño p2)
    {
        // creo un nuevo nodo para poder realizar la copia 
        Niño temp = new Niño();
        // le asigno al nodo temp los datos del nodo actual (p1) 
        temp.copiar(p1);
        // le asigno al nodo p1 los datos del nodo siguiente (p2) 
        p1.copiar(p2);
        // le asigno al nodo p2 los datos del temp 
        p2.copiar(temp);
    }
}