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 multidimensionales(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 arreglo?:La intención de este script es capturar una cantidad fijada de datos con “JOptionPane” y luego mostrarlo en pantalla. 

import javax.swing.JOptionPane;
public class PracticaFor {

public static void main (String[] args){
String nombre;
String a[];
a = new String[3];

int i = 0;
while (i < 3){
nombre = JOptionPane.showInputDialog(” Ingrese un nombre:”);
a[i] = nombre;
i++;
}
for (int j = 0; j < a.length; j++){
System.out.println(“Nombre: ” + a[j]);
}
}
}

°Bucle for each:En las últimas versiones de Java se introdujo una nueva forma de uso del for, a la que se denomina “for extendido” o “for each”. Esta forma de uso del for, que ya existía en otros lenguajes, facilita el recorrido de objetos existentes en una colección sin necesidad de definir el número de elementos a recorrer. La sintaxis que se emplea es:

 For ( TipoARecorrer nombreVariableTemporal : nombreDeLaColección ) {

}

Fíjate que en ningún momento se usa la palabra clave each que se usa en otros lenguajes, aunque al for muchas veces se le nombre como for each. Para saber si un for es un for extendido o un for normal hemos de fijarnos en la sintaxis que se emplea. La interpretación que podemos hacer de la sintaxis del for extendido es: “Para cada elemento del tipo TipoARecorrer que se encuentre dentro de la colección nombreDeLaColección ejecuta las instrucciones que se indican”. La variable local-temporal del ciclo almacena en cada paso el objeto que se visita y sólo existe durante la ejecución del ciclo y desaparece después. Debe ser del mismo tipo que los elementos a recorrer. Ejemplo

//Ejemplo aprenderaprogramar.com public void listarTodosLosNombres () {         for (String i: listaDeNombres) {         System.out.println (i); //Muestra cada uno de los nombres dentro de listaDeNombres     }   }

En este tipo de ciclos podemos darle un nombre más descriptivo a la variable temporal, por ejemplo:

//Ejemplo aprenderaprogramar.com public void listarTodosLosNombres () {         for (String nombre: listaDeNombres) {         System.out.println (nombre);              }    }

Un ejemplo de llamada desde un método main (u otro lugar) sería:

//Ejemplo aprenderaprogramar.com System.out.println ("Mostramos todos los nombres con un ciclo for-each"); lista1.listarTodosLosNombres();

El for extendido tiene algunas ventajas y algunos inconvenientes. No se debe usar siempre. Su uso no es obligatorio, de hecho, como hemos indicado, en versiones anteriores ni siquiera existía en el lenguaje. En vez de un for extendido podemos preferir usar un ciclo while. Lo haríamos así:

//Ejemplo aprenderaprogramar.com int i = 0; while (i < lista1.size() ) {        System.out.println (lista1.getNombre(i) );                                            i++;                                                     }

El ciclo for-each es una herramienta muy útil cuando tenemos que realizar recorridos completos de colecciones, por lo que lo usaremos en numerosas ocasiones antes que ciclos for o while que nos obligan a estar pendientes de más cuestiones (por ejemplo en este caso con el while, de llevar un contador, llamar en cada iteración a un método, etc.). Un for extendido en principio recorre todos y cada uno de los elementos de una colección. Sin embargo, podemos introducir un condicional asociado a una sentencia break; que aborte el recorrido una vez se cumpla una determinada condición. Escribe y compila el siguiente código ejemplo de uso de un for extendido:

import java.util.ArrayList; //Test del for extendido ejemplo aprenderaprogramar.com public class TestForExtendido {     public static void main (String [] Args) {         ArrayList <String> jugadoresDeBaloncesto = new ArrayList<String> ();         jugadoresDeBaloncesto.add ("Michael Jordan"); jugadoresDeBaloncesto.add ("Kobe Briant");         jugadoresDeBaloncesto.add ("Pau Gasol"); jugadoresDeBaloncesto.add ("Drazen Petrovic");         int i = 0;         System.out.println ("Los jugadores de baloncesto en la lista son: ");         for (String nombre : jugadoresDeBaloncesto) {  System.out.println ((i+1) + ".- " +nombre);                                                                                        i++;  }     } //Cierre del main } //Cierre de la clase

°Metodo 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 desordenanos 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(n²)
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.

°Metodo Insercion: 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(n²).

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(n²).

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.

ºBusqueda secuencial:

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 informacion 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.

ºMétodo Secuencial: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.