Ejercicio 44

#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;
    }
}