El programa departamental de niños bajos en peso, quiere recolectar la información de los niños entre uno y seis años de los municipios de Sahagún, Montería y Lorica. Entre los datos relevantes del representante del niño (madre o padre) están la identificación y el nombre. En cuanto al niño se requiere tener el número de registro civil, el nombre, la talla y peso.
Para la solución se deben implementar las clases necesarias que permitan llenar una lista doblemente enlazada, que guarde la información recolectada de los niños en cada municipio. El programa debe realizar las siguientes operaciones sobre los nodos almacenados en la lista doblemente enlazada:
- Agregar la información del niño y su representante al final de la lista.
- Insertar la información de un nuevo niño, entre dos nodos existentes.
- Agregar la información de un niño al principio de la lista (agregar nodos por la cabeza de la lista).
- Ordenar la información de la lista teniendo en cuenta el peso de los niños registrados.
- Eliminar la información de un niño y su representante.
- Mostrar la cantidad de nodos que hay en la lista
- Eliminar un nodo de la lista
El director del programa departamental de niños bajos en peso requiere que la aplicación cuente con un menú de opciones para realizar las operaciones descritas anteriormente y para generar los siguientes informes sobre los datos almacenados en la lista.
- Generar un listado por municipios, con la información de todos los niños registrados; se debe tener un consolidado de cuántos niños tiene el programa en cada municipio.
- Se considera que los niños entre 2 y 3 años con un peso menor de 15 kilos están bajos de peso, lo mismo para los niños entre 4 y 6 años que pesan menos de 25 kilos. La dirección quiere un listado con la información de los niños que estén en estas condiciones y saber las cantidades en cada municipio para enviar unos mercados con una dieta especial.
- Los niños entre 4 y 6 años que midan menos de un metro de estatura se consideran que están bajos de estatura, por esta razón se requiere saber la cantidad de niños que están bajos de talla en cada municipio.
#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);
}
}
