Ejercicio 41

#include <iostream>
// se incluye la clase Triangulo para despues llamar a sus metodos 
#include "Triangulo.h"

using namespace std;

int main(void)
{
    float a,b,c;

    // se crea un objeto de la clase Triangulo (Instanciaciación) 
    Triangulo *obj=new Triangulo();
    cout << "====INTRODUZCA LAS LONGITUDES DEL TRIANGULO====" << endl << endl;
    // se pide el primer valor 
    cout << "Digite longitud A:" << endl;
    cout << ">> ";
    cin >> a;
    // se encapsula la variable a 
    obj->setValorA(a);
    // se pide el segundo valor 
    cout << "Digite longitud B" << endl;
    cout << ">> ";
    cin >> b;
    // se encapsula la variable b 
    obj->setValorB(b);

    // se pide el tercer valor 
    cout << "Digite longitud C" << endl;
    cout << ">> ";
    cin >> c;
    // se encapsula la variable c 
    obj->setValorC(c);
    cout << endl;

    if (((a+b) > c) && ((a+c) > b) && ((b+c) > a))
    {
        if ((a == b) && (b == c))
        {
            cout << "El triangulo es Equilatero." << endl << endl;

        }
        else if (((a == b) && (a != c)) || ((a == c) && (c != b)) || ((b == c)&& (c != a)) || ((c == a) && (a != b)))
        {
            cout << "El triangulo es Isoceles." << endl << endl;
        }
        else
        {
            cout << "El triangulo es Escaleno." << endl << endl;
        }
        // se muestra el area del triangulo 
        cout << "El area del triangulo es: " << obj->area() << endl;
    }
    else
    {
        cout << "Las longitudes no forman un triangulo" << endl;
    }
}

#ifndef TRIANGULO_H
#define TRIANGULO_H


class Triangulo
{
    public:
        Triangulo();
        virtual ~Triangulo();
        // se declaran los metodos publicos 
        void setValorA(float dat);
        float getValorA();
        void setValorB(float dat);
        float getValorB();
        void setValorC(float dat);
        float getValorC();
        float area();
    protected:

    private:
        // se declaran los atributos privados 
        float l1;
        float l2;
        float l3;
};

#endif // TRIANGULO_H 

#include "Triangulo.h"
#include "math.h"
Triangulo::Triangulo()
{
    // al inicializar el constructor se definiran los valores iniciales de los atributos 
    l1 = 0;
    l2 = 0;
    l3 = 0;
}

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

void Triangulo::setValorA(float dat)
{
    l1 = dat;
}
float Triangulo::getValorA()
{
    return l1;
}

void Triangulo::setValorB(float dat)
{
    l2 = dat;
}
float Triangulo::getValorB()
{
    return l2;
}

void Triangulo::setValorC(float dat)
{
    l3 = dat;
}
float Triangulo::getValorC()
{
    return l3;
}

float Triangulo::area()
{
    // declaramos una variable que almacena el semiperimetro del triangulo para poder utilizar los lados para obtener el area 
    float s = (val1 + val2 + val3)/2;
    // se utiliza la formula de heron para calcular el area 
    float area= sqrt(s*(s-val1)*(s-val2)*(s-val3));
    // retornamos el resultado 
    return area;
}

// 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
{
    // se implementa el metodo para mostrar la informacion del vector, se le pasara como parametro un objeto de la clase Ordenamiento 
    public static void mostrarVector(Ordenamiento obj)
    {
        String datosVector = "";
        for (int i = 0; i < obj.getTamano(); i++)
        {
            datosVector = datosVector+String.valueOf("ID: " + obj.getVectorDocentes(i).getId() + "\n" +
                    "Nombre: " + obj.getVectorDocentes(i).getNombre() + "\n" +
                    "Asignatura: " + obj.getVectorDocentes(i).getAsignatura() + "\n" +
                    "Numero telefonico: " + obj.getVectorDocentes(i).getNumeroTelefono() + "\n\n");
        }
        JOptionPane.showMessageDialog(null, "============ ELEMENTOS DEL VECTOR ============" + "\n" + datosVector);
    }
    // se implementa el metodo llenar para ingresar la informacion del docente 
    public static void llenar(Docentes est)
    {
        int id = Integer.parseInt(JOptionPane.showInputDialog("Digite ID del docente:"));
        est.setId(id);
        String nom = JOptionPane.showInputDialog("Digite nombre del docente:");
        est.setNombre(nom);
        String asig =JOptionPane.showInputDialog("Digite la asignatura del docente:");
        est.setAsignatura(asig);
        int tel = Integer.parseInt(JOptionPane.showInputDialog("Digite número telefonico del docente:"));
        est.setNumeroTelefono(tel);
    }
    // se implementa el metodo para mostrar el menu de opciones 
    public static int menu()
    {
        int opcion = 0;
        do
        {
            opcion = Integer.parseInt(JOptionPane.showInputDialog("====== MENU ====== \n" +
                "1. Buscar docente mediante el ID\n" +
                "2. Buscar docente mediante el número telefonico\n" +
                "3. Ordenar por Nombres \n" +
                "4. Ordenar por Asignaturas\n" +
                "5. Salir \n\n" +
                "Seleccione una opcion del 1 al 5"));
        }
        while(opcion <= 0 || opcion > 5);
        return opcion;
    }
     public static void main(String[] args)
     {
        // se crea un objeto de la clase Ordenamiento y Docentes (Instanciaciación) 
        Ordenamiento obj = new Ordenamiento();
        Docentes est;
        int numeroElementos = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite el número de elementos del vector:"));
        obj.setTamano(numeroElementos); // se pasa el dato capturado al respectivo metodo modificador.
        // se llama al metodo que crea el vector en tiempo de ejecución. 
        obj.crearVector();
        for(int i = 0; i < obj.getTamano(); i++)
        {
            est = new Docentes();
            JOptionPane.showMessageDialog(null, "============ DOCENTES ============" + "\n \n" +
                    "Ingresar la Informacón del estudiante (" + (i+1) + ")");
            llenar(est);
            obj.setVectorDocentes(i, est);
        }
        mostrarVector(obj);
        int datoBuscar; 
        int posicionDato; 
        int opcion;
        do{
            opcion = menu();
            switch(opcion) {
            case 1:
                datoBuscar = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite el ID del docente que desea buscar:"));
                posicionDato = obj.bsuquedaBinaria(datoBuscar);
                if(posicionDato != -1)
                {
                    JOptionPane.showMessageDialog(null, "Nombre: " + obj.getVectorDocentes(posicionDato).getNombre() + "\n" +
                    "Asignatura: " + obj.getVectorDocentes(posicionDato).getAsignatura() + "\n" +
                    "Numero de telefono: " + obj.getVectorDocentes(posicionDato).getNumeroTelefono());
                }
                else
                {
                    JOptionPane.showMessageDialog(null, "El docente no se encuentra en el vector");
                }
                break;
            case 2:
                datoBuscar = Integer.parseInt(JOptionPane.showInputDialog(null, "Digite el numero del docente que desea buscar:"));
                posicionDato = obj.busquedaLineal(datoBuscar);
                if(posicionDato != -1)
                {
                    JOptionPane.showMessageDialog(null, "Nombre: " + obj.getVectorDocentes(posicionDato).getNombre() + "\n" +
                    "Asignatura: " + obj.getVectorDocentes(posicionDato).getAsignatura() + "\n" +
                    "Numero de telefono: " + obj.getVectorDocentes(posicionDato).getNumeroTelefono());
                }
                else
                {
                    JOptionPane.showMessageDialog(null, "El docente no se encuentra en el vector");
                }
                break;    
            case 3:
                obj.ordenarShell();
                mostrarVector(obj);
                break;
            case 4:
                obj.ordenarIntercambio();
                mostrarVector(obj);
                break;
            default:
                break;
            }
        }while(opcion != 5);
    }
}

public class Docentes
{
    // declaramos los atributos privados de la clase 
    private int id;
    private String nombre;
    private String asignatura;
    private int num_telefono;
    
    public Docentes()
    {
        // al inicializar el constructor se definiran los valores iniciales de los atributos 
        id = 0;
        String nombre = "";
        String asignatura = "";
        num_telefono = 0;
    }
    // se declaran e implementan los metodos Setters y Getters de los atributos de la clase 
    public void setId(int val)
    {
        id = val;
    }
    public void setNombre(String val)
    {
        nombre = val;
    }
    public void setAsignatura(String val)
    {
        asignatura = val;
    } 
    public void setNumeroTelefono(int val)
    {
        num_telefono = val;
    }
    public int getId()
    {
        return id;
    }
    public String getNombre()
    {
        return nombre;
    }
    public String getAsignatura()
    {
        return asignatura;
    }
    public int getNumeroTelefono()
    {
        return num_telefono;
    }
}

public class Ordenamiento
{
    // se define un atributo para asignar el tamaño que tendrá el vector 
    int tamano;
    
    private Docentes vectorDocentes[];
    // Docentes vectorEstudiantes[20]; Esta seria forma de declarar el vector de objetos con tamaño fijo 
    
    public Ordenamiento()
    {
        tamano = 0;
        vectorDocentes = null;
    }
    public void crearVector()
    {
        vectorDocentes = new Docentes[tamano];
    }
    
    // métodos modificadores y selectores para asignar y obtener el tamaño del vector 
    public void setTamano(int val)
    {
        tamano = val;
    }
    public int getTamano()
    {
        return tamano;
    }
    
    // los métodos modificadores y selectores para agregar información al vector y obtener elementos del vector
    // se pasan como parámetros la posición (dato entero) y un objeto de la clase Docentes  
    public void setVectorDocentes(int p, Docentes obj)
    {
        vectorDocentes[p] = obj;
    }
    
    public Docentes getVectorDocentes(int p)
    {
        return vectorDocentes[p];
    }
    public void cambiar(int p1, int p2)
    {
        Docentes temp;
        temp = getVectorDocentes(p1);
        setVectorDocentes(p1, getVectorDocentes(p2));
        setVectorDocentes(p2, temp);
    }
    public void ordenarShell()
    {
        int n, cont;
        n = (getTamano()-1)/2;
        while (n != 0)
        {
            cont = 1;
            while (cont != 0)
            {
                cont = 0;
                for (int i = n; i < getTamano(); i++)
                {
                    if (getVectorDocentes(i-n).getNombre().compareTo(getVectorDocentes(i).getNombre()) > 0){
                        cambiar(i, i-n);
                        cont = cont + 1;
                    }
                }
            }
            n = n/2;
        }
    }
    public void ordenarIntercambio()
    {
        for (int i = 0; i < getTamano(); i++)
        {
            for (int j = i+1; j < getTamano(); j++)
            {
                if (getVectorDocentes(i).getAsignatura().compareTo(getVectorDocentes(j).getAsignatura()) > 0)
                {
                    cambiar(i, j);
                }
            }
        }
    }
    public void ordenarBurbuja()
    {
        for (int i=0; i < getTamano(); i++)
        {
            for (int j = 0; j < getTamano()-2; j++)
            {
                if (getVectorDocentes(j).getId() > getVectorDocentes(j+1).getId())
                {
                    cambiar(j, j+1); 
                }
            }
        }
    }
    
    public int bsuquedaBinaria(int dato)
    {
        int posicion, izq, der, centro; // estas 4 variables almacenan posiciones del vector 
        ordenarBurbuja(); // para realizar la busqueda el vector primero debera estar ordenado 
        izq = 0; // primera posición del vector 
        der = getTamano()-1; // ultima posición del vector 
        posicion = -1;
        while ((izq <= der) && (posicion == -1))
        {
            centro = (izq + der) / 2;
            if (dato == (getVectorDocentes(centro).getId()))
            {
                posicion = centro;
            }
            else if (dato < (getVectorDocentes(centro).getId()))
            {
                der = centro-1;
            }
            else
            {
                izq = centro+1;
            }
        }
        return posicion;
    }
    
    // te aclaro que la búsqueda secuencial también se le conoce como búsqueda lineal ;) 
    public int busquedaLineal(int dato)
    {
        int i; // variable para controlar el ciclo while. 
        int posicion; /* variable que devuelve la posición en la que se encuentra el elemento buscado en el vector.
                       * se Asigna el valor de -1 a la variable posición para devolver este valor en el supuesto caso de que no se
                       * encuentre el valor buscado dentro del vector.
                       */ 
        posicion = -1;
        i = 0;
        // mientra que no se llegue al final del vector y no se haya encontrado el dato buscado en el vector. 
        while ((i <= getTamano()-1) && (posicion == -1))
        {
            // si el contenido del vector en la posición i-esima es igual al dato que se esta buscando, entonces el dato si
            // esta en el vector y se devuelve la posición en donde se encuentra el dato dentro del vector. Sino que el dato, no
            // se encuentra en esa posición, y se incrementa la posición (i) para una nueva comparación. 
            if (getVectorDocentes(i).getNumeroTelefono() == dato)
            {
                posicion=i;
            }
            else
            {
                i = i+1;
            }
        }
        return posicion;
    }
}