Se desea registrar a los estudiantes de un colegio en una lista simple enlazada, se deben pedir su id, nombre y edad. Declare las clases necesarias para poder realizar las siguientes operaciones:
- Añadir un nodo por el final.
- Añadir un nodo entre el medio de dos nodos.
- Añadir un nodo por el inicio.
- Buscar un estudiante mediante su ID o por su Nombre
- Mostrar la información de todos los nodos de la lista
- Mostrar la cantidad de nodos que hay en la lista
- Eliminar un nodo de la lista
- Eliminar toda la lista
#include <iostream>
// se incluye la clase Nodo para despues llamar a sus metodos
#include "Nodo.h"
// se incluye la clase ListaSimple para despues llamar a sus metodos
#include "ListaSimple.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 el nodo de la lista
void llenar(Nodo *n, ListaSimple *obj)
{
// declaramos una variable de tipo entero id
int id;
// pedimos al usuario que ingrese la identificiación
cout << "Digite identificacion" << endl;
cout << ">> ";
// guardamos el valor en la variable id
cin >> id;
// encapsulamos la variable id
n->setId(id);
// declaramos una variable de tipo string nombre
string nom;
// pedimos al usuario que ingrese el nombre
cout << "Digite nombre" << endl;
cout << ">> ";
// guardamos el valor en la variable nombre
cin >> nom;
// encapsulamos la variable nombre
n->setNombre(nom);
// declaramos una variable de tipo entero edad
int edad;
// pedimos al usuario que ingrese la edad
cout << "Digite edad" << endl;
cout << ">> ";
// guardamos el valor en la variable edad
cin >> edad;
// encapsulamos la variable edad
n->setEdad(edad);
}
// método para mostrar la informacion de un nodo
void mostrar(Nodo *n)
{
cout << "ID: " << n->getId() << endl;
cout << "Nombre: " << n->getNombre() << endl;
cout << "Edad: " << n->getEdad() << endl << endl;
}
// método para mostrar la informacion de todos los nodos
void listarTodos(Nodo *n)
{
// declaramos una variable temp de tipo Nodo y le asignamos n
Nodo *temp = n;
// mientras haya un nodo en la lista
while(temp != NULL)
{
// se mostrara el nodo temp
mostrar(temp);
// se saltara al siguiente nodo de temp
temp = temp->getSiguiente();
}
}
// método para el menu
int menu()
{
int opcion = 0;
do
{
cout << "1. Agregar estudiante al final de la Lista" << endl;
cout << "2. Agregar estudiante entre dos Nodos existentes" << endl;
cout << "3. Agregar estudiante al principio de la lista" << endl;
cout << "4. Buscar estudiante por ID o por Nombre" << endl;
cout << "5. Mostrar nodos de la lista" << endl;
cout << "6. Cantidad de nodos que hay en la lista" << endl;
cout << "7. Eliminar nodo de la lista" << endl;
cout << "8. Eliminar toda la lista" << endl;
cout << "9. Salir" << endl;
cout << ">> ";
cin >> opcion;
system("cls");
}
while(opcion < 1 || opcion > 9);
return opcion;
}
int main(void)
{
// se crea un objeto de la clase ListaSimple (Instanciaciación)
ListaSimple *obj = new ListaSimple();
// declaro dos variable de tipo entero opcion e id
int opcion, id;
// declaro una variable de tipo string nombre
string nombre;
// declaro una variable de tipo Nodo aux
Nodo *aux;
// declaro una variable de tipo Nodo nd
Nodo *nd;
do
{
// le asignare a la variable opcion el valor que retorne el método menu
opcion = menu();
switch(opcion)
{
case 1:
aux = new Nodo();
llenar(aux, obj);
system("cls");
obj->agregarFinal(aux);
break;
case 2:
cout << "Digite ID del estudiante que quiere agregar" << endl;
cout << ">> ";
cin >> id;
system("cls");
nd = obj->buscarId(id);
if(nd != NULL)
{
aux = new Nodo();
llenar(aux, obj);
obj->agregarEntreNodos(nd, aux);
}
else
{
cout << "La ID NO se encuentra en la lista" << endl << endl;
}
break;
case 3:
aux = new Nodo();
llenar(aux, obj);
obj->agregarInicio(aux);
if(obj->getCabeza() != NULL)
{
listarTodos(obj->getCabeza());
}
else
{
cout << "La Lista Está Vacía." << endl << endl;
}
break;
case 4:
int opc;
do
{
cout << "Como desea realizar la busqueda:" << endl;
cout << "1. ID" << endl;
cout << "2. Nombre" << endl;
cout << ">> ";
cin >> opc;
system("cls");
}
while(opc < 1 || opc > 2);
if(opc == 1)
{
cout << "Digite ID del estudiante a Buscar" << endl;
cout << ">> ";
cin >> id;
aux = obj->buscarId(id);
if(aux != NULL)
{
mostrar(aux);
}
else
{
cout << "La información del estudiante No se encuentra en la lista" << endl << endl;
}
}
else
{
cout << "Digite Nombre del estudiante a Buscar" << endl;
cout << ">> ";
cin >> nombre;
aux = obj->buscarNombre(nombre);
if(aux != NULL)
{
mostrar(aux);
}
else
{
cout << "La información del estudiante No se encuentra en la lista" << endl << endl;
}
}
break;
case 5:
aux = obj->getCabeza();
if (aux != NULL)
{
listarTodos(aux);
}
else
{
cout << "No hay nodos en la lista." << endl << endl;
}
break;
case 6:
cout << "Hay " << obj->contarNodos() << " nodos en la lista." << endl << endl;
break;
case 7:
aux = obj->getCabeza();
if (aux != NULL)
{
obj->eliminar(aux);
cout << "Se elimino un nodo correctamente." << endl << endl;
}
else
{
cout << "No hay nodos en la lista." << endl << endl;
}
break;
case 8:
obj->limpiar();
cout << "La lista se ha eliminado." << endl << endl;
break;
default:
break;
}
}
while(opcion != 9);
}
#ifndef NODO_H
#define NODO_H
#include <iostream>
using namespace std;
class Nodo
{
public:
Nodo();
virtual ~Nodo();
// se declaran los metodos publicos
void setId(int n);
int getId();
void setNombre(string n);
string getNombre();
void setEdad(int n);
int getEdad();
void setSiguiente(Nodo *n);
Nodo *getSiguiente();
protected:
private:
// se declaran los atributos privados
int id;
string nombre;
int edad;
Nodo *siguiente;
};
#endif // NODO_H
#include "Nodo.h"
Nodo::Nodo()
{
// al inicializar el constructor se definiran los valores iniciales de los atributos
id = 0;
nombre = "";
siguiente = NULL;
}
Nodo::~Nodo()
{
//dtor
}
// métodos setters y getters de la clase Nodo
void Nodo::setId(int n)
{
id = n;
}
int Nodo::getId()
{
return id;
}
void Nodo::setNombre(string n)
{
nombre = n;
}
string Nodo::getNombre()
{
return nombre;
}
void Nodo::setEdad(int n)
{
edad = n;
}
int Nodo::getEdad()
{
return edad;
}
void Nodo::setSiguiente(Nodo* n)
{
siguiente = n;
}
Nodo* Nodo::getSiguiente()
{
return siguiente;
}
#ifndef LISTASIMPLE_H
#define LISTASIMPLE_H
#include "Nodo.h"
#include <iostream>
using namespace std;
class ListaSimple
{
public:
ListaSimple();
virtual ~ListaSimple();
// se declaran los metodos publicos
void setCabeza(Nodo *n);
Nodo *getCabeza();
Nodo *ultimo();
int contarNodos();
void agregarFinal(Nodo *n);
void agregarEntreNodos(Nodo *nd, Nodo *nuevo);
void agregarInicio(Nodo *n);
Nodo *buscarId(int c);
Nodo *buscarNombre(string n);
void eliminar(Nodo *nd);
void limpiar();
protected:
private:
// se declaran los atributos privados
Nodo *cabeza;
};
#endif // LISTASIMPLE_H
#include "ListaSimple.h"
#include <string>
ListaSimple::ListaSimple()
{
// al inicializar el constructor se definiran los valores iniciales de los atributos
cabeza = NULL;
}
ListaSimple::~ListaSimple()
{
//dtor
}
// método set y get del atributo de la clase
void ListaSimple::setCabeza(Nodo* n)
{
cabeza = n;
}
Nodo* ListaSimple::getCabeza()
{
return cabeza;
}
// método para obtener al ultimo nodo de la lista
Nodo* ListaSimple::ultimo()
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo *temp = cabeza;
// mientras haya un nodo en la lista
while (temp != NULL)
{
// si el siguiente nodo de temp apunta o es igual a null
if (temp->getSiguiente() == NULL)
{
// se rompe el ciclo
break;
}
else
{
// sino se salta al siguiente nodo de siguiente
temp = temp->getSiguiente();
}
}
// se retorna el nodo temp
return temp;
}
// método para contar los nodos que hay en la lista
int ListaSimple::contarNodos()
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo *temp = cabeza;
// se inicializa una variable contador en 0
int contador = 0;
// mientras haya un nodo en la lista
while (temp != NULL)
{
// se incrementa la variable contador
contador++;
// se salta al siguiente nodo de temp
temp = temp->getSiguiente();
}
// se retorna la variable contador
return contador;
}
// metodo para agregar al final de la lista
void ListaSimple::agregarFinal(Nodo* n)
{
// si la cabeza apunta a null
if (cabeza == NULL)
{
// entonces, la cabeza apuntara al nodo n
setCabeza(n);
}
else
{
// el ultimo nodo apuntara al nodo n
ultimo()->setSiguiente(n);
}
}
// método para agregar un nodo entre dos nodos de la lista
void ListaSimple::agregarEntreNodos(Nodo* nd, Nodo* nuevo)
{
// donde nd es el Nodo anterior (A) y nuevo es el NUEVO NODO
// se necesita dos nodos A & B por ejemplo
// A debe apuntar al nuevo nodo auxiliar y el nodo auxiliar
// apuntara al nodo B.
nuevo->setSiguiente(nd->getSiguiente());
// el siguiente de nuevo sera el siguiente de A (B).
nd->setSiguiente(nuevo);
// el NODO nd (A) apunta al nodo nuevo.
}
// método para agregar al inicio de la lista
void ListaSimple::agregarInicio(Nodo* n)
{
// el nodo n apuntara a la cabeza
n->setSiguiente(cabeza);
// la cabeza apuntara al nodo n
setCabeza(n);
}
// método para buscar por id
Nodo* ListaSimple::buscarId(int c)
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo *temp = cabeza;
// mientras haya un nodo en la lista
while(temp != NULL)
{
// si el id del nodo temp es igual al parametro c
if(temp->getId() == c)
{
// se rompe el ciclo
break;
}
else
{
// sino el nodo temp apuntara a su siguiente nodo
temp = temp->getSiguiente();
}
}
// se retorna el nodo temp
return temp;
}
// método para buscar por nombre
Nodo* ListaSimple::buscarNombre(string n)
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo *temp = cabeza;
// mientras haya un nodo en la lista
while(temp != NULL)
{
// si el nombre del nodo temp es igual al parametro n
if(temp->getNombre().compare(n) == 0)
{
// se rompe el ciclo
break;
}
else
{
// sino el nodo temp apuntara a su siguiente nodo
temp = temp->getSiguiente();
}
}
return temp;
}
// método para eliminar un nodo de la lista
void ListaSimple::eliminar(Nodo* nd)
{
Nodo *anterior;
// si el nodo a eliminar en la lista es el primero entonces
if (nd == cabeza)
{
// la cabeza apuntara a su siguiente
cabeza = cabeza->getSiguiente();
}
else
{
// se busca el nodo anterior al que se quiere eliminar (nd)
anterior = cabeza;
while (anterior->getSiguiente() != nd)
{
anterior = anterior->getSiguiente();
}
// el nodo anterior ahora apuntara al siguiente nodo de nd
anterior->setSiguiente(nd->getSiguiente());
}
nd->setSiguiente(NULL);
}
// método para limpiar toda la lista
void ListaSimple::limpiar()
{
while(cabeza != NULL)
{
eliminar(cabeza);
}
}
// 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(Nodo n, ListaSimple obj)
{
// pedimos el ID
int id = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite identificación:"));
// encapsulamos la variable id
n.setId(id);
// pedimos el nombre
String nom = JOptionPane.showInputDialog(null, "Digite nombre:");
// encapsulamos la variable nom
n.setNombre(nom);
// pedimos la edad
int edad = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite edad:"));
// encapsulamos la variable edad
n.setEdad(edad);
}
// método para mostrar un nodo de la lista
public static void mostrar(Nodo n)
{
// se inicializa una variable de tipo entero datos en ""
String datos = "";
datos += String.valueOf("ID: " + n.getId()+ "\n" +
"Nombre: " + n.getNombre() + "\n" +
"Edad: " + n.getEdad());
// se muestra los datos
JOptionPane.showMessageDialog(null, "=========== INFORMACÓN DE LOS NODOS DE LA LISTA =========== \n"+ datos);
}
// método para listar toda la lista
public static void listarTodos(Nodo n)
{
// inicializo una variable de tipo nodo temp en n
Nodo temp = n;
// mientras haya un nodo en la lista
while(temp != null)
{
// muestro el nodo temp
mostrar(temp);
// salto al siguiente nodo de temp
temp = temp.getSiguiente();
}
}
// método para el menu del programa
public static int menu()
{
int opcion = 0;
do
{
opcion = Integer.parseInt(JOptionPane.showInputDialog("=========== SELECCIONE UNA OPCIÓN DEL MENÚ =========== \n" +
"1. Agregar estudiante al final de la Lista \n" +
"2. Agregar estudiante entre dos Nodos existentes\n" +
"3. Agregar estudiante al principio de la lista\n" +
"4. Buscar estudiante por ID o por Nombre\n" +
"5. Mostrar nodos de la lista\n" +
"6. Cantidad de nodos que hay en la lista\n" +
"7. Eliminar nodo de la lista\n" +
"8. Eliminar toda la lista\n" +
"9. Salir\n\n" +
" Seleccione una opción del 1 al 9:"));
}
while(opcion < 1 || opcion > 9);
return opcion;
}
public static void main(String[] args)
{
// se crea un objeto de la clase Triangulo (Instanciaciación)
ListaSimple obj = new ListaSimple();
// se declaran dos variables: opcion e id de tipo entero
int opcion, id;
// se declara una variable de tipo String nombre
String nombre;
// se declara una variable de tipo nodo aux
Nodo aux;
do
{
opcion = menu();
switch(opcion)
{
case 1:
aux = new Nodo();
llenar(aux, obj);
obj.agregarFinal(aux);
break;
case 2:
id = Integer.parseInt(JOptionPane.showInputDialog("Digite ID del estudiante que quiere agregar: "));
Nodo nd = obj.buscarId(id);
if(nd != null)
{
aux = new Nodo();
llenar(aux, obj);
obj.agregarEntreNodos(nd, aux);
}
else
{
JOptionPane.showMessageDialog(null, "La ID NO se encuentra en la lista");
}
break;
case 3:
aux = new Nodo();
llenar(aux, obj);
obj.agregarInicio(aux);
if(obj.getCabeza() != null)
{
listarTodos(obj.getCabeza());
}
else
{
JOptionPane.showMessageDialog(null, "La Lista Está Vacía....");
}
break;
case 4:
int opc;
do
{
opc = Integer.parseInt(JOptionPane.showInputDialog("Como desea realizar la busqueda:\n 1. ID\n 2. Nombre"));
}
while(opc < 1 || opc > 2);
if(opc == 1)
{
id = Integer.parseInt(JOptionPane.showInputDialog("Digite ID del estudiante a Buscar: "));
aux = obj.buscarId(id);
if(aux != null)
{
mostrar(aux);
}
else
{
JOptionPane.showMessageDialog(null, "La información del estudiante No se encuentra en la lista");
}
}
else
{
nombre = JOptionPane.showInputDialog("Digite Nombre del estudiante a Buscar: ");
aux = obj.buscarNombre(nombre);
if(aux != null)
{
mostrar(aux);
}
else
{
JOptionPane.showMessageDialog(null, "La información del estudiante No se encuentra en la lista");
}
}
break;
case 5:
aux = obj.getCabeza();
if (aux != null)
{
listarTodos(aux);
}
else
{
JOptionPane.showMessageDialog(null, "No hay nodos en la lista.");
}
break;
case 6:
JOptionPane.showMessageDialog(null, "Hay " + obj.contarNodos() + " nodos en la lista.");
break;
case 7:
aux = obj.getCabeza();
if (aux != null)
{
obj.eliminar(aux);
JOptionPane.showMessageDialog(null, "Se elimino un nodo correctamente.");
}
else
{
JOptionPane.showMessageDialog(null, "No hay nodo en la lista.");
}
break;
case 8:
obj.limpiar();
JOptionPane.showMessageDialog(null, "La lista se ha eliminado.");
break;
default:
break;
}
}
while(opcion != 9);
}
}
public class Nodo
{
// se declaran los atributos privados
private int id;
private String nombre;
private int edad;
private Nodo siguiente;
public void Nodo()
{
// le asigno valores por defecto a los atributos en el constructor de la clase Nodo
id = 0;
nombre = "";
edad = 0;
siguiente = null;
}
// metodos setters y getters de la clase Nodo
public void setId(int n)
{
id = n;
}
public int getId()
{
return id;
}
public void setNombre(String n)
{
nombre = n;
}
public String getNombre()
{
return nombre;
}
public void setEdad(int n)
{
edad = n;
}
public int getEdad()
{
return edad;
}
public void setSiguiente(Nodo n)
{
siguiente = n;
}
public Nodo getSiguiente()
{
return siguiente;
}
}
public class ListaSimple
{
// se define un atributo privado de tipo Nodo
private Nodo cabeza;
public ListaSimple()
{
// le asigno un valor por defecto al atributo cabeza en el constructor de la clase ListaSimple
cabeza = null;
}
// método set y get del atributo de la clase ListaSimple
public void setCabeza(Nodo n)
{
cabeza = n;
}
public Nodo getCabeza()
{
return cabeza;
}
// método para obtener al ultimo nodo de la lista
public Nodo ultimo()
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo temp = cabeza;
// mientras haya un nodo en la lista
while(temp != null)
{
// si el siguiente nodo de temp apunta o es igual a null
if(temp.getSiguiente() == null)
{
// se rompe el ciclo
break;
}
else
{
// sino se salta al siguiente nodo de siguiente
temp = temp.getSiguiente();
}
}
// se retorna el nodo temp
return temp;
}
// método para contar los nodos que hay en la lista
public int contarNodos()
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo temp = cabeza;
// se inicializa una variable contador en 0
int contador = 0;
// mientras haya un nodo en la lista
while(temp != null)
{
// se incrementa la variable contador
contador++;
// se salta al siguiente nodo de temp
temp = temp.getSiguiente();
}
// se retorna la variable contador
return contador;
}
// metodo para agregar al final de la lista
public void agregarFinal(Nodo n)
{
// si la cabeza apunta a null
if(cabeza == null)
{
// entonces, la cabeza apuntara al nodo n
setCabeza(n);
}
else
{
// el ultimo nodo apuntara al nodo n
ultimo().setSiguiente(n);
}
}
// método para agregar un nodo entre dos nodos de la lista
public void agregarEntreNodos(Nodo nd, Nodo nuevo)
{
// donde nd es el Nodo anterior (A) y nuevo es el NUEVO NODO
// se necesita dos nodos A & B por ejemplo
// A debe apuntar al nuevo nodo auxiliar y el nodo auxiliar
// apuntara al nodo B.
nuevo.setSiguiente(nd.getSiguiente());
// el siguiente de nuevo sera el siguiente de A (B).
nd.setSiguiente(nuevo);
// el nodo nd (A) apunta al nodo nuevo.
}
// método para agregar al inicio de la lista
public void agregarInicio(Nodo n)
{
// el nodo n apuntara a la cabeza
n.setSiguiente(cabeza);
// la cabeza apuntara al nodo n
setCabeza(n);
}
// método para buscar por id
Nodo buscarId(int c)
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo temp = cabeza;
// mientras haya un nodo en la lista
while(temp != null)
{
// si el id del nodo temp es igual al parametro c
if(temp.getId() == c)
{
// se rompe el ciclo
break;
}
else
{
// sino el nodo temp apuntara a su siguiente nodo
temp = temp.getSiguiente();
}
}
// se retorna el nodo temp
return temp;
}
// método para buscar por nombre
Nodo buscarNombre(String n)
{
// se inicializa una variable temp de tipo Nodo en la cabeza
Nodo temp = cabeza;
// mientras haya un nodo en la lista
while(temp != null)
{
// si el nombre del nodo temp es igual al parametro n
if(temp.getNombre().equals(n))
{
// se rompe el ciclo
break;
}
else
{
// sino el nodo temp apuntara a su siguiente nodo
temp = temp.getSiguiente();
}
}
return temp;
}
}
