JAVA ARREGLOS

Definición: 

Los arreglos se pueden definir como objetos en los que podemos guardar mas de una variable, es decir, al tener un único arreglo, este puede guardar múltiples variables de acuerdo a su tamaño o capacidad, es importante recordar que las variables guardadas deben ser del mismo tipo, por ejemplo: Si tenemos un arreglo de tipo Numérico que puede almacenar 10 variables, solo podrá almacenar 10 números diferentes, no otras variables como caracteres o Strings.
Existen 2 tipos de arreglos, los unidimensionales, y los multi-dimensionales(generalmente 2 dimensiones y se les denomina matrices), en esta lección veremos como declarar y utilizar los arreglos unidimensionales, estos son mas sencillos y fáciles de comprender, y pueden servirnos para muchas aplicaciones.

Como llenar un programa:


Bucle FOR-EACH:

Una de las cosas que incorporó Java 5 fue el bucle for-each en Java. Esta estructura nos permite recorrer una Colección o un array de elementos de una forma sencilla. Evitando el uso de Iteradores o de un bucle for normal.
De la forma tradicional podríamos recorrer un array de la siguiente forma:
    



  1. 
String a[] = {"Avila", "Burgos", "León", "Palencia", "Salamanca", "Segovia", "Soria", "Valladolid", "Zamora"};
    



    2. 





  2. 

    



    3. 





  3. 
for (int x=0;x<a.length;x++)
    



    4. 





  4. 
System.out.println(a[x]);
    



    5. 





  5. 

    



    6.
En este caso nos estamos apoyando en el tamaño del array, con la propiedad length y en una variable contador, la cual vamos incrementando hasta que llegue a el tamaño del array.
Para recorrer una Colección, una lista en este caso, podríamos hacerlo con un Iterador de la siguiente forma:
    



  1. 
List<String> list = new ArrayList<String>();
    



    2. 





  2. 

    



    3. 





  3. 
// Añadimos elementos
    



    4. 





  4. 
list.add("Victor");
    



    5. 





  5. 
list.add("Amaya");
    



    6. 





  6. 
list.add("Julio");
    



    7. 





  7. 

    



    8. 





  8. 
// Obtenemos un Iterador y recorremos la lista.
    



    9. 





  9. 
ListIterator<String> iter = list.listIterator(list.size());
    



    10. 





  10. 
while (iter.hasPrevious())
    



    11. 





  11. 
System.out.println(iter.previous());
    



    12.
Para la colección hemos creado un Iterador que nos permite recorrer los elementos de la colección.
El bucle for-each en Javanos permite realizar estas mismas operaciones de una forma muy sencilla. La estructura del bucle for-each sería de la siguiente forma:
    



  1. 
for (TipoBase variable: ArrayDeTiposBase) {..}
    



    2.
Así, para recorrer un array, tendríamos lo siguiente:
    



  1. 
String array[] = {"Avila", "Burgos", "León", "Palencia", "Salamanca", "Segovia", "Soria", "Valladolid", "Zamora"};
    



    2. 





  2. 

    



    3. 





  3. 
for (String elemento: array)
    



    4. 





  4. 
System.out.println(elemento);
    



    5. 





  5. 

    



    6.
Y para la colección, esto otro:
    



  1. 
List<String> list = new ArrayList<String>();
    



    2. 





  2. 

    



    3. 





  3. 
// Añadimos elementos
    



    4. 





  4. 
list.add("Victor");
    



    5. 





  5. 
list.add("Amaya");
    



    6. 





  6. 
list.add("Julio");
    



    7. 





  7. 

    



    8. 





  8. 
for (String nombre: list)
    



    9. 





  9. 
System.out.println(nombre);
    



    10. 





  10. 

    



    11.
Vemos que se unifica la forma de listar los elementos y se simplifica el código.
Algoritmos de ordenación. Método de la Burbuja:
El algoritmo de la burbuja es uno de los métodos de ordenación más conocidos y uno de los primeros que aprenden los programadores. Consiste en comparar pares de elementos adyacentes en un array y si están desordenamos intercambiarlos hasta que estén todos ordenados.Si A es el array a ordenar, se realizan A.length-1 pasadas. Si la variable i es la que cuenta el número de pasadas, en cada pasada i se comprueban los elementos adyacentes desde el primero hasta A.length-i-1 ya que el resto hasta el final del array están ya ordenados. Si los elementos adyacentes están desordenados se intercambian.
El método de ordenación de la burbuja en java para ordenar un array A es el siguiente:
public static void burbuja(int [] A){
         int i, j, aux;
         for(i=0;i<A.length-1;i++)
              for(j=0;j<A.length-i-1;j++)
                   if(A[j+1]<A[j]){
                      aux=A[j+1];
                      A[j+1]=A[j];
                      A[j]=aux;
                   }
}

 Ejemplo de ejecución:


Ya están ordenados, pero los dos bucles for seguirán ejecutándose hasta el final.
El tiempo de ejecución del algoritmo de la burbuja es del orden O(n2)
Es uno de los peores algoritmos de ordenación en cuanto a tiempo de ejecución, solamente es recomendable su uso para ordenar listas con un número pequeño de elementos.

Ordenamiento por Inserción directa:


El método de ordenación por inserción directa consiste en recorrer todo el array comenzando desde el segundo elemento hasta el final. Para cada elemento, se trata de colocarlo en el lugar correcto entre todos los elementos anteriores a él o sea entre los elementos a su izquierda en el array.
Dada una posición actual p, el algoritmo se basa en que los elementos A[0], A[1], ..., A[p-1] ya están ordenados.
De forma gráfica el proceso que sigue el método de inserción directa es el siguiente:
 El método de Ordenamiento por inserción directa en Java es el siguiente:
public static void insercionDirecta(int A[]){
    int p, j;
    int aux;
    for (p = 1; p < A.length; p++){ // desde el segundo elemento hasta
              aux = A[p]; // el final, guardamos el elemento y
              j = p - 1; // empezamos a comprobar con el anterior
              while ((j >= 0) && (aux < A[j])){ // mientras queden posiciones y el
                                                                    // valor de aux sea menor que los
                             A[j + 1] = A[j];       // de la izquierda, se desplaza a
                             j--;                   // la derecha
              }
              A[j + 1] = aux; // colocamos aux en su sitio
    }
}
En el peor de los casos, el tiempo de ejecución en O(n2).
En el mejor caso (cuando el array ya estaba ordenado), el tiempo de ejecución de este método de ordenamiento es O(n).
El caso medio dependerá de cómo están inicialmente distribuidos los elementos. Cuanto más ordenada esté inicialmente más se acerca a O(n) y cuanto más desordenada, más se acerca a O(n2).
El peor caso el método de inserción directa es igual que en los métodos de burbuja y selección, pero el mejor caso podemos tener ahorros en tiempo de ejecución.

Búsqueda secuencial en un arreglo usando Java:


Tal vez también te interese Búsqueda binaria en un arreglo usando Java
Saludos a todos.

Antes de iniciar, debemos familiarizarnos con el concepto de arreglo, he aquí la definición por Wikipedia:

Arreglo: Es una zona de almacenamiento continuo, que contiene una serie de elementos del mismo tipo.

Para efectos de ésta explicación visualice el arreglo como una serie de cajas unidas donde podemos almacenar datos del mismo tipo, los arreglos están indexados con una serie de números de van de menor a mayor y que sirven para hacer referencia a cada uno de las cajas dentro del arreglo, en java esta indices comienzan en 0.



Los arreglos y en general las estructuras de datos nos permiten almacenar información o datos, pero ahora nos seria de utilidad hallar la forma de encontrar los datos que almacenamos en las mismas, para tal fin se han diseñados algoritmo de búsquedas.

Como el titulo lo sugiere trataremos el método de búsqueda secuencial.

Los dos elementos fundamentales a tener en cuentas son: un arreglo con datos objeto de la búsqueda y un elemento o criterio de búsqueda.
El método de búsqueda secuencial consiste en ir comparando el elemento o criterio de búsqueda con cada uno de los elementos en el arreglo, esto se hace recorriendo el arreglo y deteniéndose en cada elemento y hacer la comparación, en caso de ser verdadera la comparación, guardar la posición el elemento o dato.

He aquí el código:

 
public  int busquedaSecuencial(int []arreglo,int dato){
 int posicion = -1;
  for(int i = 0; i < arreglo.length; i++){//recorremos todo el arreglo
      if(arreglo[i] == dato){//comparamos el elemento en el arreglo con el buscado
    posicion = i;//Si es verdadero guardamos la posicion
    break;//Para el ciclo
   }
 }
 return posicion;
}
Este método nos halla la posición del elemento o dato buscado pero en su primero coincidencia, si queremos que nos halle la posición de la ultima coincidencia, lo único que tenemos que hacer es eliminar la linea donde aparece 'break'.
Si el resultado del método anterior es -1, significa que el elemento no se encuentra en el arreglo.
Ahora cabe la pregunta, ¿y si el elemento que deseo buscar aparece varias veces en el arreglo y yo deseo conocer cada una de estas posiciones, como hago?
Lo que hacemos es deshacernos de la linea 'break' para que el vector sea recorrido en su totalidad, y de alguna forma ir almacenando cada una de las posiciones resultantes de las comparaciones verdaderas.
He aquí el código:

 
public String busquedaSecuencial2(int []arreglo,int valor){
 String posicion = "";
  for(int i = 0; i < arreglo.length; i++){
   if(arreglo[i] == valor){
    posicion += i+",";    
   }
  }
 return posicion;
}
Aunque pude haber usado un 'ArrayList' o 'Vector' preferí usar un 'String' porque asumo que el lector de éste articulo está mas familiarizado con esta ultima que con los dos primeros términos.
Como siempre esperando que lo escrito les sea de utilidad.



Comentarios

Publicar un comentario