Matrices: Enprogramaciónse denominamatriz,vector(de una sola dimensión) oformación(en inglésarray)1 a una zona de almacenamiento contiguo que contiene una serie de elementos del mismo tipo, los elementos de la matriz.2 Desde el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila (o filas y columnas si tuviera dos dimensiones).
En principio, se puede considerar que todas las matrices son de una dimensión, la dimensión principal, pero los elementos de dicha fila pueden ser a su vez matrices (un proceso que puede ser recursivo), lo que nos permite hablar de la existencia de matrices multidimensionales, aunque las más fáciles de imaginar son los de una, dos y tres dimensiones.
Estas estructuras de datos son adecuadas para situaciones en las que el acceso a los datos se realice de forma aleatoria e impredecible. Por el contrario, si los elementos pueden estar ordenados y se va a utilizar acceso secuencial sería más adecuado utilizar unalista, ya que esta estructura puede cambiar de tamaño fácilmente durante la ejecución de un programa.
1.- Matriz simétrica: He aquí un ejemplo de lo que es una matriz simétrica:
2.- Matriz transpuesta: Aquí un ejemplo de lo que es:
3.- Ejercicios resueltos :
Ejemplo numero 1:
public static void main( String args[ ]){
int [ ][ ]A ={{5,6,2,1,3}, {1,2,3,4,5}, {6,7,8,9,0}}; /** * Primero vamos a imprimir la matriz dada */System.out.println(“La matriz dada es: “); for(int i = 0; i < A.length; i++){ for(int j = 0; j < A[0].length; j++){ System.out.print(” ” + A[i][j] + ” “); } System.out.println(); } /**Ahora podemos observar como la matriz anterior la cual es 3 X 5 * se convierte en una 5 x 3, es decir la filas se convierten en columnas * y las columnas se convierten en filas. Lo que hacemos a continuación * es intercambiar los for para imprimir de la manera que queremos. */System.out.println(“La matriz transpuesta es: “); for(int j = 0; j < A[0].length; j++){ for(int i = 0; i < A.length; i++){ System.out.print(” ” + A[i][j] + ” “); } System.out.println(); } } }
Ejemplo numero 2:
public class Transpuesta {
public static void main(String[] arg) { int x; // int y; Scanner s = new Scanner(System.in); System.out.print("digite la dimencion de la matriz"); x = s.nextInt();
int m[][] = new int[x][x];
for (int i = 0; i < m.length; i++) { for (int j = 0; j < m[0].length; j++) { System.out.print("los valores de la matriz"); m[i][j] = s.nextInt();
}
} System.out.println("matriz origunal"); for (int i = 0; i < m.length; i++) { for (int j = 0; j < m[0].length; j++) { System.out.print(m[i][j]); } System.out.println();
} System.out.println("matriz transpuesta"); for (int i = 0; i < m.length; i++) { for (int j = 0; j < m.length; j++) { System.out.print(m[j][i]);
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 faciles de comprender, y pueden servirnos para muchas aplicaciones.
Declaración:
La estructura de declaración de un arreglo es la siguiente:
tipo_dedato [] nombre_variable; //tambien puede declararse “tipo_dedato nombre_variable[];”
ejemplos:
1
String array[]; //donde array es un arreglo que guardara variables tipo Strings
2
doublearray2[]; //donde array2 es un arreglo que guardara variabels tipo double
3
int[] array3; //donde array3 es un arreglo que guardara variables tipo int(numericas)
Vídeo de como declarar arreglos en java:
2.- ¿Cómo llenar un arreglo?
He aquí un ejemplo:
He aquí una vídeo demostración:
3.- 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:
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:
List<String> list = new ArrayList<String>();
// Añadimos elementos
list.add("Victor");
list.add("Amaya");
list.add("Julio");
// Obtenemos un Iterador y recorremos la lista.
ListIterator<String> iter = list.listIterator(list.size());
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:
for(TipoBase variable: ArrayDeTiposBase){..}
Así, para recorrer un array, tendríamos lo siguiente:
Te muestro el funcionamiento del método de la burbuja en Java, uno de los principales algoritmos de ordenación que existen, te muestro un vídeo bastante explicativo del funcionamiento, otro vídeo más de nuestro ejemplo en ejecución y por ultimo te muestro el código fuente del ejemplo donde podremos ordenar un arreglo de números de forma descendente y otro de forma ascendente.
La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo uno de los más sencillo de implementar.
/** * @param args the command line arguments */ public static void main(String[] args) { int tamanio,posicion,temporal ,contador,iteracion ; //aca lo que se hizo es llenar el vector de una sola vez pero se podria ingresar los numeros via teclado int vector[]={6,8,5,4,2,1,9,0,7,3}; tamanio=vector.length; String salida="elementos en su orden original \n "; JTextArea areaSalida =new JTextArea(); for(contador=0;contador<tamanio;contador++){ salida=salida + " " + vector[contador];} // ahora aremos el ordenamiento de numeros usando el metodo de la burbuja for(iteracion=1;iteracion<tamanio;iteracion++){ for(posicion=0;posicion<tamanio-1;posicion++){ if(vector[posicion]>vector[posicion+1]){ temporal=vector[posicion]; vector[posicion]=vector[posicion+1]; vector[posicion+1]=temporal;}} salida=salida + "\n elementos ordenadanados asendentemente \n "; for(contador=0;contador<tamanio;contador++){ salida=salida + "" + vector [contador];} areaSalida.setText(salida); JOptionPane.showMessageDialog(null,areaSalida);}
//dudas comenten o si quieren el projecto solo de abrir en netbeans comenten
JOptionPane.showMessageDialog(null, "by ramirez"); }} 5.- Método de Inserción.
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.
6.- Búsqueda Secuencial.
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.
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.
