Estructura de Datos

Ø  Estructura de Datos 

    

      Una estructura de datos  es una clase de datos que se puede  caracterizar por su organización  y operaciones definidas sobre ella. Algunas veces a estas  estructuras se les llama  tipo de datos.

     El primer objetivo de toda computadora es el manejo de la información o datos. Un dato es la expresión general que describe los objetos con los cuales opera una computadora. La mayoría de las computadoras pueden trabajar con varios tipos de datos. Los algoritmos y los programas correspondientes operan sobre datos.

     Los tipos de datos simples pueden ser organizados en diferentes estructuras de datos ya sean en:

     Estructura de Datos Estáticas:                

Son aquellas en las que el espacio ocupado en memoria se define en tiempo de compilación y no puede ser modificado durante la ejecución del programa. Corresponden a este tipo los arrays y registros.

·       

Estructuras de Datos Dinámicas:

Son aquellas en las que el espacio ocupado en memoria puede ser modificado en tiempo de ejecución. Corresponden a este tipo las listas, árboles y grafos. Estas estructuras no son soportadas en todos los lenguajes.

Objetivo De La Estructura De Datos

Identificar, seleccionar y aplicar eficientemente tipos de datos abstractos métodos de ordenamientos y búsqueda para optimizar el rendimiento de soluciones de problemas del mundo real.

En la estructura de datos se utilizan los diagramas UML para así después poder programarlo en el lenguaje de programación Java.

Ejemplo en Diagrama UML y Programación:

1.    Elabore un Programa que solicite 3 números al usuario y los imprima ordenados del mayor a menor.

• Diagrama UML: 

• 
  Programación Java:

// nombre de la clase

public class NumeroMayor

{

// atributos

int Num1, Num2, Num3;

// metodos

public static void main()

{

Leernumeros();

Ordenar();

Imprimir();

}

}

Nota: en el lenguaje Java la doble diagonal (//), significa comentario.

Publicado por: Dickner Steven Barrios & Yenifer Mina Castillo

Practica 1.- Área y Perímetro de 3 rectángulos y 3 triángulos

Problema 1.-

Elaborar un programa que calcule el área y perímetro de 3 rectángulos y 3 triángulos.

• Diagrama UML:

NOTA: El contenido de los siguientes programas están codificados en NetBeans.

• Programación en Java:

1.- Aquí comienza la clase de Rectángulo:

public class Rectángulo 

{

      private int base;

    private int altura;

    private int área;

    private int perímetro;

     

    public int getBase() {

        return base;

    }

    public void setBase(int base) {

        this.base = base;

    }

    public int getAltura() {

        return altura;

    }

    public void setAltura(int altura) {

        this.altura = altura;

    }

    public int getArea() {

        return area;

    }

    public void setArea(int area) {

        this.area = area;

    }

    public int getPerimetro() {

        return perimetro;

    }

    public void setPerimetro(int perimetro) {

        this.perimetro = perimetro;

    }

    // metodos  del UML

    public void captura()

    {

        base=Integer.parseInt(JOptionPane.showInputDialog("Base del rectangulo: "));

        altura=Integer.parseInt(JOptionPane.showInputDialog("Altura del rectangulo: "));

    }

    public void calcularArea()

    {

      area= base* altura;

    }

    public void calcularPerimetro()

    {

        perimetro=base+base+altura+altura;

    }

    public void  imprimir()

    {

       JOptionPane.showMessageDialog(null,"El area  del rectangulo es: " + area);

       JOptionPane.showMessageDialog(null,"El perimetro del rectangulo es: " + perimetro);

       }

}

2.- Aquí comienza la clase de Triangulo:

public class Triangulo 
{
      private int base;
    private int altura;                           
    private int area;
    private int perimetro;

    public int getBase() {
        return base;
    }


    public void setBase(int base) {
        this.base = base;
    }
    public int getAltura() {
        return altura;
    }

    public void setAltura(int altura) {
        this.altura = altura;
    }

    public int getArea() {
        return area;
    }

    public void setArea(int area) {
        this.area = area;
    }
     
    public int getPerimetro() {
        return perimetro;
    }
      
    public void setPerimetro(int perimetro) {
        this.perimetro = perimetro;
    }
    // metodos  del UML
    public void captura()
    {
        base=Integer.parseInt(JOptionPane.showInputDialog("Base del triangulo "));
        altura=Integer.parseInt(JOptionPane.showInputDialog("Altura del triangulo "));        
    }
    public void calcularArea()
    {
      area= (base* altura) /2;
    }
    public void calcularPerimetro()
    {
        perimetro=base + altura + altura;
    }
    public void  imprimir()
    {
       JOptionPane.showMessageDialog(null,"El area  del triangulo es: " + area);
       JOptionPane.showMessageDialog(null,"El perimetro del triangulo es: " + perimetro);
       }
}

3.- Aquí comienza la clase de Solución:

public class Solución 

{
    public static void main(String []args)
    {
        //declarando los objetos
        
        Rectangulo r1, r2, r3;
   //creando los objetos
         r1=new Rectangulo();
         r2=new Rectangulo();
         r3=new Rectangulo(); 
         
         r1.captura();
         r1.calcularArea();
         r1.calcularPerimetro();
         r1.imprimir();

         r2.captura();
         r2.calcularArea();
         r2.calcularPerimetro();
         r2.imprimir();

         r3.captura();
         r3.calcularArea();
         r3.calcularPerimetro();
         r3.imprimir();
         
          Triangulo t1, t2, t3;
    t1= new Triangulo();
    t2= new Triangulo();
    t3= new Triangulo();

    t1.captura();
    t1.calcularArea();
    t1.calcularPerimetro();
    t1.imprimir();
    
    t2.captura();
    t2.calcularArea();
    t2.calcularPerimetro();
    t2.imprimir();
    
    t3.captura();
    t3.calcularArea();
    t3.calcularPerimetro();
    t3.imprimir();
    }

}

* En el código verán que aparece:    public int getBase() y     public void setBase(int base) la palabra base es el atributo o la variable y aparece por que los atributos se encapsulan. 

¿Que es y para que sirve encapsular los atributos?

El encapsulamiento consiste en unir en la Clase las características y comportamientos, esto es, las variables y métodos. Es tener todo esto es una sola entidad. En los lenguajes estructurados esto era imposible. Es evidente que el encapsulamiento se logra gracias a la abstracción y el ocultamiento.

El objetivo del encapsulamiento, al no permitir que un miembro de una clase sea accesible por todo el mundo, es evitar que los usuarios de una clase realicen operaciones no permitidas, como llamar a métodos que están pensados solamente para ser utilizados desde dentro de la clase, o asignar arbitrariamente valores a los miembros dato, de tal manera que los objetos tomen un estado corrupto. Digamos que la encapsulación sirve para:

1. Evitar errores lógicos de programación.

2. Aislar lo que el usuario de la clase necesita conocer y le es útil, de los detalles de implantación.

3. Impedir que el estado de un objeto (conjunto de valores que toman los miembros dato de ese objeto durante un intervalo de tiempo), sea erróneo.

4. Programar de una manera más elegante y minimista.

5. Facilitar el uso de la clase al resto de los programadores. 

¿ Como encapsular los atributos? 

Lo veremos enseguida:

= Después verán el siguiente recuadro:

= Después aparece el siguiente recuadro y harán lo que se les indica. =

  

= Y al final aparecerá codificado de la siguiente manera, y asi llegamos al final de como encapsular atributos. =

* Al correr el programa es así como aparecen los recuadros en donde se piden los datos.

               * Primero se pide el valor de la altura del rectángulo.

* Después el área del rectángulo.

* Aquí es donde ya se calculo el área del rectángulo.

* Aquí es donde ya se calculo el perímetro del rectángulo.

 * Después se pide el valor de la altura del triangulo.

 * Después el área del rectángulo.

* Aquí es donde ya se calculo el perímetro del rectángulo.

    * Aquí es donde ya se calculo el área del rectángulo.

Nota: Cada método se repetirá dependiendo del número de veces que se capture al iniciar el programa o el valor que le des a la variable N.

Conclusión

Usar los diagramas UML y en la forma que se programa es muy fácil poder programar y más que nada nos ahorramos tiempo cosa que es muy importante en el ámbito ya sea laboral o estudiantil.

Publicado por: Dickner Steven Barrios & Yenifer Mina Castillo

Practica 2.- Uso de la Recursividad para calcular el factorial de un numero

¿Recursividad?

Es una técnica que existe para resolver problemas a través de llamadas al mismo problema.

Nota: con la recursividad puede sustituir a los ciclos pero no son muy eficientes.

• Practica 2.- calcular el factorial de un numero 

1. Diagramas UML

2.- Aquí comienza la clase Factorial:

public class Factorial 

{

private int numero;

   private int fat;

    public int getNumero() {

        return numero;

    }

    public void setNumero(int numero) {

        this.numero = numero;

    }

    public int getFat() {

        return fat;

    }

    public void setFat(int fat) {

        this.fat = fat;

    }

           public void captura ()

           {

               numero=Integer.parseInt(JOptionPane.showInputDialog("Numero:  "));

           }

           public int calcularFactorial(int n)

           {

              if(n==1 || n==0)

              {

                  return 1;

           }

           else

           {

               fat= n*calcularFactorial(n-1);

               return fat;

           }

         }

          public void imprimirFactorial()

          {

              JOptionPane.showMessageDialog(null,"El Factorial es: " +fat);

          }

}

3.- Aquí comienza la clase solución:

public class Solucion_factorial

{

    public static void main(String []arg)

    {

        Factorial n;

        n=new  Factorial();

        int numVeces;

        numVeces=Integer.parseInt(JOptionPane.showInputDialog("Factorial a calcular"));

        for(int i=1; i<numVeces; i++)

        {

            //n.captura();

        n.calcularFactorial(i);

        n.imprimirFactorial();

    }

    }

}

* Aquí ya comienza a correr el programa pidiendo el factorial a calcular.

* Aquí se muestra como ya se lleva a cabo el método calcular factorial. 

Conclusión 

La recursividad es una técnica muy útil en el ámbito de los lenguajes de programación orientada a objetos  ya que tiene sus ventajas y desventajas ya que puede sustituir a los ciclos pero pues al mismo tiempo pueden ser no muy eficientes.

Publicado por: Dickner Steven Barrios & Yenifer Mina Castillo

Practica 3.- Torres de Hanói Algoritmo de Intercambio

 En esta practica veremos sobre el tema de Torres de Hanói que enseguida quedara una breve reseña.

TORRES DE HANÓI

La torre de Hanói, es un juego lógico matemático, que consiste en la apilar los 8 discos por los cuales está conformada en una delas tres estacas del tablero. Este juego es considerado en muchas ocasiones como introducción al área de logaritmos pues el encontrar la manera acerca de cómo tener la misma organización de los discos en otra torre lo convierte en un problema al cual la lógica y la razón le darán solución.

El juego, en su forma más tradicional, consiste en tres varillas verticales. En una de las torres se apila un número indeterminado de discos (elaborados de madera) que determinará la complejidad de la solución, por regla general se consideran ocho discos. Los discos se apilan sobre una varilla en tamaño decreciente. No hay dos discos iguales, y todos ellos están apilados de mayor a menor radio en una de las varillas, quedando las otras dos varillas vacantes. El juego consiste en pasar todos los discos de una torre ocupada a una de las otras torres vacías. Para realizar este objetivo, es necesario seguir tres simples reglas:

1.   Sólo se puede mover un disco cada vez.

2.   Un disco de mayor tamaño no puede descansar sobre uno más pequeño que él mismo.

3.   Sólo puedes desplazar el disco que se encuentre arriba en cada torre.

Existen diversas formas de realizar la solución final, todas ellas siguiendo estrategias diversas.

Practica 3.- Torres de Hanói Algoritmo de Intercambio

                        == Comenzamos con el Diagrama UML ==

 ** Después continuamos con la codificación **

1.- Aquí comienza la clase de Rectángulo:

import javax.swing.JOptionPane;

public class Torres_hanoi 

{                                                          

 private int numdiscos;

 private int numovi;

   

    public int getNumdiscos() {

        return numdiscos;

    }      

    public void setNumdiscos(int numdiscos) {

        this.numdiscos = numdiscos;

    }

    public int getNumovi() {

        return numovi;

    }

    public void setNumovi(int numovi) {

        this.numovi = numovi;

    }

        

    public void captura()

        {

       numdiscos=Integer.parseInt(JOptionPane.showInputDialog("Numero de discos:  "));

        }

    public void intercambio(int numdiscos, int A,int B,int C)

    {

     if (numdiscos==1)

      {

      setNumovi(getNumovi() +1);

      JOptionPane.showMessageDialog(null,"Mover disco del poste A al poste B");

      }

     else

       {

    intercambio(numdiscos - 1, A,C,B);

    setNumovi(getNumovi() +1);

    JOptionPane.showMessageDialog(null,"Mover disco del poste A al poste C");

    intercambio(numdiscos-1, B,A,C);

    JOptionPane.showMessageDialog(null,"Mover disco del poste B al poste C");

  

       }

    }

    public void totalMovimientos()

       {

        JOptionPane.showMessageDialog(null,"El total de movimientos fueron:  "+ numovi);

       }

}

2.- Aquí comienza la clase solución

import javax.swing.JOptionPane;

public class Solucion_hanoi

{

    public static void main (String [] args)

  {

    Torres_hanoi  objeto;

    objeto=new Torres_hanoi  ();

    objeto.captura();

    objeto.intercambio(objeto.getNumdiscos(), 'A', 'B', 'C');

    objeto.totalMovimientos();

  }

}

* Aquí ya comienza a correr el programa 

 * Después introduces número de discos a usar.

* A continuación como se mueven los discos de un poste a otro poste.

* Movimientos totales de un poste a otro poste.

* Y aquí concluye el final del programa.

= = = Conclusión = = =

Llegamos a la conclusión de que el juego de las Torres de Hanói es un juego matemático en el cual podemos ver o demostrar las habilidades que tenemos y al igual esto nos sirve mucho para resolver algún problema ya que con la lógica y la razón llegaran ala solución. 

Publicado por: Dickner Steven Barrios & Yenifer Mina Castillo