Estructuras Estáticas

Estructuras Estáticas

Estructuras Estáticas

CONCEPTO:Las estructuras estáticas son mucho más sencillas de manipular que las dinámicas, y son suficientes para resolver la mayoría de los problemas. Las estructuras dinámicas, de manejo más difícil, permiten aprovechar mejor el espacio en memoria y tienen aplicaciones más específicas.

Además, se pueden mencionar como una clase de estructura de datos diferente las estructuras externas, entendiendo como tales aquéllas que no se almacenan en la memoria principal (RAM) del ordenador, sino en alguna memoria secundaria (típicamente, un disco duro). Las estructuras externas, que también podemos denominar archivos o ficheros, son en realidad estructuras dinámicas almacenadas en memoria secundaria.

ARREGLOS: 

Un arreglo puede definirse como un grupo o una colección finita, homogénea y ordenada de elementos. Los arreglos pueden ser de los siguientes tipos:

• Unidimencional - vectores
• Bidimencional - matrices
• multidimencional - cubos

             * Arreglos Unidimensionales

Arreglo Unidimensional

Cada elemento  del arreglo representa la edad de una persona, así para referirnos a la edad de la persona ubicada en la posición número 5, lo haremos indicando el nombre del arreglo y el respectivo subíndice: EDAD (5)

En general para hacer  referencia  a un elemento de un arreglo unidimensional lo haremos así:  

NOMBRE DEL ARREGLO [ Subíndice ]

  

             Un arreglo unidimensional es un tipo de datos estructurado que está formado de 
             una  colección finita y ordenada                                                   

             de datos del mismo tipo. Es la estructura natural para modelar listas de elementos 
             iguales.

             El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir,
             podemos acceder a cualquier   

             elemento del arreglo sin tener que consultar a elementos anteriores o posteriores,
             esto   mediante el uso de un  índice para cada elemento del arreglo que nos da su
             posición relativa.

             Para implementar arreglos unidimensionales se debe reservar espacio en memoria,
             y se debe proporcionar la dirección base del arreglo, la cota superior y la inferior.

           *Arreglos bidimencionales

Cada elemento representa la nota de un estudiante (filas) en cada una de las 5 asignaturas (columnas), así para referirnos a la nota del estudiante ubicado en la posición número 3 en la asignatura 4, lo haremos indicando el nombre del arreglo, el número del estudiante y la posición de la asignatura, así : NOTAS ( 3 , 4 )  

NOMBRE DEL ARREGLO [ No. Fila , No.  Columna ]

           Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado, finito
        ordenado y homogéneo. El   

        acceso a ellos también es en forma directa por medio de un par de índices.

        Los arreglos bidimensionales se usan para representar datos que pueden verse como
        una tabla con filas y columnas. La primera dimensión del arreglo representa las                      
        columnas,cada elemento contiene un valor y cada dimensión representa una relación.

        *Arreglos multidimencionales

           Este también es un tipo de dato estructurado, que está compuesto por n
           dimensiones.          
           Para hacer referencia a cada componente del arreglo es necesario utilizar n índices,
           uno para cada dimensión  Para determinar el número de elementos en este tipo de  
           arreglos se usan las siguientes fórmulas:

                     RANGO (Ri) = lsi - (lii + 1)

                    No. TOTAL DE ELEMENTOS = R1 * R2* R3 * ...* Rn

            donde:

                    i = 1 ... n

                    n = No. total de dimensiones

                    Para determinar la dirección de memoria se usa la siguiente formula:

                    LOC A[i1,i2,i3,...,in] = base(A) + [(i1-li1)*R3*R4*Rn + (i2-li2)*R3*R2*... (in - 

                    lin)*Rn]*w

VECTOR:es un arreglo, generalmente asociados a los arreglos unidimensionales.  Es una zona de almacenamiento contiguo, que contiene una serie de elementos del mismo tipo y se distinguen entre sí por un índice tambien es una estructura de datos estaticas.

                      --->Secuencia de elementos
                      --->El tamaño es conocido
                      --->Se encuentran en momoria adyacente
                      --->Mismo tipo
                     ---> Empiezan el la posición '0' cero
                     --->Se accede a los elementos a travez de '1' indice

            Int [ ] arreglo; \\ Ojo esto solo es la declaracion

            Int  [ ] arreglo = new int [10];\\new : asignacion dinamica de memoria

                         Int [ ] arreglo

                         Arreglo = new int[10];

EJEMPLO EN LENGUAJE  JAVA;

Diagrama de claces

Implementación:


Paquete Presentación
Clase Formulario.java:




package Presentacion;

import Logica.Pares;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Formulario
{
    public static void main (String arg []) throws IOException
    {
        int vector[]=new int[10];
        int i;
        System.out.println("Digite los valores: ");
        for(i=0;i<=9;i++)
        {
            vector[i]=leer();
        }
        Pares objeto=new Pares();
        System.out.println("Los numeros pares son: "+ objeto.numeros_pares(vector));
    }
    public static int leer() throws IOException
    {
        InputStreamReader entrada=new InputStreamReader (System.in);
        BufferedReader lectura=new BufferedReader (entrada);
        String numero=lectura.readLine();
        return(Integer.parseInt(numero));
    }
} 

Paquete Lógica.
Clase Pares.java:


package Logica;

public class Pares
{
    private int dato;

    public boolean verifica_par(int dato)
    {
        if(dato%2==0)
        {
            return (true);
        }
        else
        {
            return(false);
        }
    }
    public String numeros_pares(int vector[])
    {
        String cadena = "";
        int lista[]=new int[10];
        int listaordenada[]=new int[10];
        int j=0;
        int temp;
        for(int i=0;i<=9;i++)
        {
            if(verifica_par(vector[i]))
            {
                lista[j]=vector[i];
                j++;
            }
        }

        for(int l=8;l>0;l--)
        {
            for(int lo=0;lo<=l;lo++)
            {
                if(lista[lo]>lista[lo+1])
                {
                    temp=lista[lo+1];
                    lista[lo+1]=lista[lo];
                    lista[lo]=temp;
                }
            }
        }

        for(int k=0;k<=9;k++)
        {
           cadena+=" "+lista[k];
        }
        return(cadena);
    }

    public int getDato() {
        return dato;
    }

    public void setDato(int dato) {
        this.dato = dato;
    }
}