ENSAYO ESTRUCTURA DE DATOS.

JOSE ALFREDO OROZCO MIRAMMONTES

QUE SON LAS ESTRUCTURAS DE DATOS.

En una práctica, que la mayor parte de esta información nose útil no aparece aislada en forma de Datos simples, sino que lo hace de forma organizada y estructurada.

Los diccionarios, guías, enciclopedias, etc., son colecciones de datos que serían inútiles si no estuvieran organizadas de acuerdo con unas determinadas reglas. Pero también es tener bien estructurada toda esa información supone ventajas adicionales, al facilitar el acceso y el manejo de los datos. Por ello parece razonable desarrollar la idea de la agrupación de datos, que tengan un cierto tipo de estructura y organización interna.

Con  esta estructura de datos  hace que se hagan grandes rasgos, sobre  colección de datos (normalmente de tipo simple) que se caracterizan para su organización y las operaciones que se definen en ellos. Pero también , las estructura de datos vendrán caracterizada por unas ciertas relaciones entre los datos que la constituyen (este es el orden de las componentes de un vector de números reales), como por las operaciones posibles en ella. Esto supone que podamos expresar formalmente, mediante un conjunto de reglas, las relaciones y operaciones posibles (tales como insertar nuevos elementos o como eliminar los datos.

.

 LISTAS EN LAZADAS

Pueden expresarse de muchas formas de implementar una lista en implementaciones basadas en arrays como un nodo con el cual se de la conexión de un elemento.

De Java, se puede  insertar un elemento en cualquier lugar que no sea el final de la lista puede ser complejo, ya que todo estos elementos que se encuentran entre el punto de inserción y el final de la lista deberán desplazarse una posición para dejar hueco para la nueva entrada. Ocurre algo similar con la eliminación.

Por ello, las listas suelen utilizar una implementación

Enlazada.

PILAS

Una pila si las inserciones y extracciones las hacemos por un mismo lado de la lista. También se las llama listas LIFO (Last In First Out - último en entrar primero en salir.

Para esto es importante que una pila al ser una lista puede almacenar en el campo de información cualquier tipo de valor (int, char, float, vector de caracteres, un objeto.

Pero para estudiar el mecanismo de utilización de una pila supondremos que en el campo de información almacena un entero (para una fácil interpretación y codificación. Inicialmente . la PILA está vacía y decimos que el puntero raiz apunta a null (Si apunta a null decimos que no tiene una dirección de memoria. Pero para esto se debe declarar un nodo debemos utilizar una clase. En este caso la información del nodo (info) es un entero y siempre el nodo tendrá una referencia de tipo Nodo, que le llamamos sig.
El puntero sig apunta al siguiente nodo o a null en caso que no exista otro nodo. Este puntero es interno a la lista. También definimos como un  puntero de tipo Nodo llamado raiz. Este puntero tiene la dirección del primer nodo de la lista.

En caso de estar vacía la lista, raiz apunta a null (es decir que no tiene dirección). Uno de los métodos más importantes que debemos entender en una pila es el de insertar un elemento en la pila.
Al método llega la información e inserta, en este caso en particular es un valor entero.es hacer la creación de un nodo requiere dos pasos definición de un puntero o referencia a un tipo de dato Nodo.

COLAS

Una lista sobre  una cola si las inserciones se hace que  al final y las extracciones las hacemos por el frente de la lista. También se las llama listas FIFO (First In First Out - primero en entrar primero en salir)

Esto hace que  un programa nos permita administrar una lista tipo cola. Desarrollaremos los métodos de insertar, extraer, vacia e imprimir.

Recordemos que defininiremos al puntero llamado nuevo, luego creamos el nodo con el operador new y cargamos los dos campos, el de información con lo que llega en el parámetro y el puntero con null ya que se insertará al final de la lista, es decir no hay otro después de este.

Un ejemplo:

Y por último todo  puntero externo fondo debe apuntar al nodo apuntado por nuevo.

            

Con esto ya tenemos correctamente enlazados los nodos en la lista tipo cola. Para se tiene que recordar que el puntero nuevo desaparece cuando se sale del método insertar, pero el nodo creado no se pierde porque queda enlazado en la lista.

CONCLUCION

Esto nos hace pensar que Java se pueden  realizar conversiones entre valores y objetos de las clases de envoltura de tipos, mediante la conversión.

Se aprendió también que las listas enlazadas son elementos de datos que están “alineados en una fila”.  También vio que una aplicación puede realizar operaciones de inserción y eliminación de datos en cualquier parte de una lista enlazada. Se Aprendió que las estructuras de datos tipo pila y cola son versiones restringidas de listas. En cuanto a las pilas, vio que las operaciones de insertar y eliminar datos se realizan sólo en la parte superior.

 Esta estructura de datos nos sirve para sacarnos areas de cuadrado tambien del tringulo o puede que tambien del area de un circulo como se puede ver este ejemplo.
 /**
 * @(#)Figurasgeometricas.java
 *
 *
 * @author
 * @version 1.00 2014/4/1
 */
import matematicas.Area;
import java.util.Scanner;

public class Figurasgeometricas {
       
    /**
     * Creates a new instance of <code>Figurasgeometricas</code>.
     */
    public Figurasgeometricas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int sel,lado,l1,l2,base,altura,radio;
        double pi=3.141621;
        Scanner entrada=new Scanner(System.in);
        Area area=new Area();
        do{
            System.out.println("1)cuadrado");
            System.out.println("2)rectangulo");
            System.out.println("3)triangulo");
            System.out.println("4)circulo");
            System.out.println("0)salir");
       
        System.out.println("elija una opcion");
       
        seleccion=entrada.nextInt();
       
            switch (sel){                
                  case 1:
                  System.out.println ("Dame el lado");
                  lado =entrada.nextInt();
                  System.out.println("El area es : "+area.cuadrado(lado));
                  break;
                     
                  case 2 :
                  System.out.println ("Dame el lado 1: ");
                  l1=entrada.nextInt();
                  System.out.println ("Dame el lado 2: ");
                  l2=entrada.nextInt();
                  System.out.println ("El area es ="+area.rectangulo (l1,l2));
                  break;
                 
                 
                  case 3 :
                  System.out.println ("Dame la base: ");
                  base=entrada.nextInt();
                  System.out.println ("Dame la altura: ");
                  altura=entrada.nextInt();
                  System.out.println ("El area es ="+area.triangulo (base,altura));
                  break;
                 
                   case 4 :
                  System.out.println ("Dame el radio: ");
                  radio=entrada.nextInt();
                  System.out.println("El area es ="+area.circulo (radio,PI));
                  break;   
                 
                  case 0: break;
                  default:
                  System.out.println ("Te equivocaste de opcion");
                  break;
                 
                  }
}        while (sel!=0);
    }

 Este como se puede ver declaramos dos enteros con letras para definir en dos arreglos con los cuales al solicitarle al usuario nos arroje cuantos columnas van a ser op como cuantas renglones serian para meter la informacion que el usuario desea.
despues dentro main se dara new con esto daremos cuantos numeros o columnas se utilizaran
/**
 * @(#)ArregloMuitidimencional.java
 *
 *
 * @author
 * @version 1.00 2014/4/4
 */
import java.util.Scanner;
public class ArregloMuitidimencional {
       
    /**
     * Creates a new instance of <code>ArregloMuitidimencional</code>.
     */
    public ArregloMuitidimencional() {
    }   

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        int n,m;
        int [][]x;
       
        Scanner ent= new Scanner(System.in);
       
        System.out.print("ingrese num. de renglones :");    
        n= ent.nextInt();
        System.out.println("ingrese num. de columnas :");
        m= ent.nextInt();
             
        x= new int [n] [m];
        leerdatos (x);
              //presentar (x);
             
     }
             
     public static void leerdatos(int [][]a)  
         {
            Scanner ent = new Scanner(System.in);
            System.out.println("ingrese los datos");
           
           
            for (int i=0; i< a.length ; i++)
               
         
         
            {
                 for (int j=0; j < a[i].length; j++)
                    
                 {
                     System.out.print("a["+i+"]["+j+"]");
                    
                   a[i][j] = ent.nextInt();
                 }
                
          }

         }
         public static void presentar(int[][]a)
         {
            
          for (int i=0; i< a.length ; i++)
             
              {
                  for (int j=0; j < a[i].length; j++)
                  {
                      System.out.print(a[i][j]+" ");
                  }
                   System.out.println();
         }     
                 
     }




Metodo de la burbuja
/**
 * @(#)MetododeBurbuja.java
 *
 *
 * @author
 * @version 1.00 2014/4/6
 */
 import java.util.Scanner;
public class MetododeBurbuja {
       
    /**
     * Creates a new instance of <code>MetododeBurbuja</code>.
     */
    public MetododeBurbuja() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int n ;
        int [] x;     //// declaracion de las varibles que utilizaremos
       
        Scanner ent= new Scanner(System.in);
       
        System.out.print("ingrese num de digitos a ordenar :"); //aqui esta agrega los digitos   
        n= ent.nextInt();
       
             
        x= new int [n] ;
        leerdatos (x);     // esto es el  metodo para leer los datos
       
    }
     public static void leerdatos(int [] a)  
         {
            Scanner ent = new Scanner(System.in);
            System.out.println("ingrese los digitos ");//aqui le damos que nos leera los digitos que vamos a ingresar
                                                             //al arreglo
           

            for (int i=0; i< a.length ; i++)
            {
                 System.out.println("ingrese el digito en la posicion " + i +":");
                 a [i]= ent.nextInt();
                 }
               
        presentardatos(a);       // aqui presentaremos los datos a registrar
}
                              ///  como presentaremos los datos
       
      public static void presentardatos(int [] a)
      {
     
          System.out.println(" los digitos que se ingresaron son" );
               
         
          for (int i=0; i< a.length ; i++)
                                                                    /// este ya es para que todos los dato los arroje de arriba o 
            {                                                       //hacia abajo
                 System.out.print(a [i] + " ");
                 }
          ordenardatos(a);
      }
     
        public static void ordenardatos (int [] a)
      {
          int aux;                                                      
          for(int i = 0; i < a.length; i++){
                                                        
                    for (int j = i + 1; j < a.length; j++){ 
                        //ordena los datos
                        if(a[j]< a[i]){
                            
                            aux = a[i];
                                                                ///// el auxiliar nos ayudara para que nos
                            a[i] = a[j];                              //toda la informacion caiga ahi
                            a[j] = aux ;
                           //muestra el arreglo ordenado
                        }
                    }         
                }
                datosarreglados(a);
      }
     public static void datosarreglados(int [] a)
      {                                                                       // nos dara todos los datos ya acomodados
     
          System.out.println(" los digitos ordenados son" );
               
         
          for (int i=0; i< a.length ; i++)
             
            {
                 System.out.print(a [i] + " ");
                 }
         
      }

}


/**
 * @(#)ColaCircular.java
 *
 *
 * @author
 * @version 1.00 2014/4/11
 */
import java.util.Scanner;
public class ColaCircular {
       
    /**
     * Creates a new instance of <code>ColaCircular</code>.
     */
    public ColaCircular() {
    }
   
    /**
     * @param args the command line arguments
     */
        public static int frente=0,fin=0;
    public static void main(String[] args) {
        // TODO code application logic here
       
       
        int max, opcion;
        int [] colacir;
       
        Scanner ent= new Scanner (System.in);
       
        System.out.print("tamano de cola");
     
        max = ent.nextInt();
       
        fin = max - 1;
       
        frente = siguiente(fin,max);
        colacir=new int[max];
       
        do{
            System.out.println("1. inserta");
           
            System.out.println("2. extraer");
           
            System.out.println("3. presentar");
           
            System.out.println("4. limpiar");
           
            System.out.println("5. salir");
           
            opcion= ent.nextInt();
           
            switch (opcion){
               
                case 1: insertar (colacir,max);
                         break;
                case 2: eliminar (colacir, max);
                         break;
                case 3: presentar (colacir, max);
                         break;                  
               
                case 4: fin=max-1;
                        frente=siguiente(fin,max);
                        
                    break;
                case 5:  break;
               
                                 
            default:
                break;
           
            }
            System.out.print("opcion equivocada");
                         break;
          }      
        while (opcion!=5);
          
   
        }
       public static int siguiente ( int posicion,int max)
       
         {
             return (posicion+1) % max;
         }
        
         public static void  insertar (int []c, int max)
        
         {
             Scanner ent= new Scanner(System.in);
            
             if (frente == siguiente (siguiente(fin,max),max))
                
                 System.out.println("cola llena");
                
             else{
                
                 System.out.println("ingrese valor");
                
                 fin=siguiente(fin,max);
                 c[fin]= ent.nextInt();
                
             }
        }
         public static void presentar(int []p, int m){
         
          if(frente==siguiente(fin,m))
             
          System.out.println("!!!   COLA VACIA   !!!");
   
          else{
             
         for(int i=frente; i!=siguiente(fin,m); i=siguiente(i,m)){
            
         System.out.println("Cola["+i+"] = "+p[i]);
     }
   }
 }
          public static void eliminar(int []posicion, int max){
               if(frente==siguiente(fin,max))
                  System.out.println(" !!! COLA VACIA!!!");
   
               else{
            
               System.out.println("Eliminando el elemento <<"+frente+">> = "+posicion1[frente]);
        
         frente=siguiente(frente,max);
    }
   }

Metodo Pilas
/**
 * @(#)pilas.java
 *
 *
 * @author
 * @version 1.00 2014/4/7
 */
import java.util.Scanner;
public class pilas {
       
    /**
     * Creates a new instance of <code>pilas</code>.
     */
    public pilas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       Scanner ent=new Scanner(System.in);
       int n,opcion, cima=0;
           int []pila;
       
        //1)push(ingresar datos a pila)
        //2)pop(eliminar datos de pila)
        //3)presentar pila
        //4)limpiar pila
        //5)terminar       
           
          
            // se solicita el tamano de la pila
           
        System.out.println("tamano de pila");
         n=ent.nextInt();
         pila=new int [n];
        
         do{
               System.out.println("1.push");
               System.out.println("2.pop");
              System.out.println("3. presentar pila");
              System.out.println("4. limpiar pila");
              System.out.println("5. terminar");
             
              opcion=ent.nextInt();
              switch(opcion)
                  {
                 
                  case 1: cima=push(pila,cima);
                             break;
                  case 2: pop(pila,cima);
                             break;
                  case 3: presentar (pila, cima);
                             break;
                  case 4: cima=0;          
                             break;
                            
                  case 5:    break;
                 
                  default:
                      System.out.println("opcion equivocada");          
              }
         }
          while (opcion!=5);
         }
       
           public static int  push(int[]p,int c)
              
           {   Scanner ent= new Scanner(System.in);
          
               if(c < p.length)
                   {
                     c++;
                   System.out.print("ingrese elemento" +c+ ":");
                   p[c-1]= ent.nextInt();
               }
              
               else{
                   System.out.println("pila llena");     //// aqui es cuando realmente se encuentra llena la pila
                   System.out.println("elimine un elemento");
                  
               }
               return c;
           }
           public static int pop(int[]p,int c)
               {
                if (c!=0)
                {
                    System.out.println("se elimino el elemento"+c+" = "+ p[c-1]);
                        c--;
                }
                else
                {
                    System.out.println("pila sin datos");
                }
               return c;
          }
           public static void presentar (int []p,int c)
           {
               if (c!=0)
               {
                   System.out.println("mostrando datos de pila");
                  for (int i = c-1; i>= 0;i--)
                  {
                      System.out.println("elemento"+i+":"+p[i]);
                  }
                     
               }
               else
                   {
                   System.out.println("pila vacia");
               }
           }
            
    }