You are on page 1of 16

Encabezado: Vectores y Matrices 1

Arreglos unidimensionales (o vectores) y Bidimensionales (o matrices)

Luis Fernando Polo Piñeres

Universidad de Cartagena

Notas de autor

Luis Fernando Polo Piñeres, Facultad de Ingenieria, Universidad de Cartagena

La correspondencia relacionada con este trabajo debe ser dirigida a Luis Polo

Piñeres, Facultad de Ingenieria, Universidad de Cartagena

Contacto: luis.chily@gmail.com
Encabezado: Vectores y Matrices 2

Tabla de contenido
ESTRUCTURA DE DATOS............................................................................................. 3

Los arreglos pueden ser de los siguientes tipos: ............................................................ 4

Arreglo Unidimensionales o Vectores ....................................................................... 4

Declaración de un Arreglo Unidimensional o Vectores ................................................ 5

Ingresar Datos .................................................................................................................... 7

Búsqueda en un Arreglo Dimensional Java ....................................................................... 8

Mostrar el Contenido de un Arreglo en Java ..................................................................... 9

Operaciones Habituales Con Arrays: Buscar, Añadir, Insertar, Borrar........................... 10

Arreglos Bidimensionales (matrices)............................................................................... 11

Como Declarar una Matriz .............................................................................................. 11

Declarar una matriz en java: ........................................................................................ 11

Como Llenar una Matriz.................................................................................................. 12

Como Acceder a los Elementos de una Matriz................................................................ 15


Encabezado: Vectores y Matrices 3

ESTRUCTURA DE DATOS

Las estructuras de datos estáticas son aquellas en las que el tamaño ocupado en memoria

se define antes de que el programa se ejecute y no puede modificarse durante la ejecución

del programa. Estas estructuras están implementada en casi todos los lenguajes de

programación: arreglos (vector/matriz), registros, ficheros o archivos, conjuntos (Pascal).

También existen las estructuras de datos dinámicas no tienen las limitaciones o

restricciones en el tamaño de memoria ocupada, que son propias de las estructuras estáticas.

Mediante el uso de un tipo de datos especifico denominado puntero, es posible construir

estructuras de datos dinámicas, que son soportadas por la mayoría de lenguajes. Las

estructuras de datos dinámicas por excelencia son: las listas (enlazadas, pilas y colas), arboles

(binarios, árbol-b) y grafos.

Pero en este trabajo hablaremos sobre las estructuras de datos estáticas, que son las que

veremos a continuación.
Encabezado: Vectores y Matrices 4

Un arreglo (vector o matriz) es un conjunto finito y ordenado de elementos homogéneos.

La propiedad ordenada significa que el elemento primero, segundo,…., n-ésimo de un

arreglo puede ser identificado.

Los arreglos pueden ser de los siguientes tipos:

 De una dimensión.

 De dos dimensión.

 De tres o más dimensión.

Arreglo Unidimensionales o Vectores

Un arreglo unidimensional es un tipo de datos estructurado que está formado por una

colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar

listas de elementos iguales. Los datos que se guarden en los arreglos todos deben ser del

mismo tipo.

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.
Encabezado: Vectores y Matrices 5

Para implementar arreglos unidimensionales se debe reservar espacio en memoria.

Los arreglos nos permiten hacer un conjunto de operaciones para manipular los datos

guardados en ellos, estas operaciones son: ordenar, buscar, insertar, eliminar, modificar

entre otras que veremos a continuación.

Declaración de un Arreglo Unidimensional o Vectores

Para declarar vectores hay una notación algorítmica que es la siguiente:

TIPO

<nombre del tipo arreglo> = arreglo[dimensión] de <tipo de dato>

Var

Identificador de la variable: <nombre del tipo arreglo>

Ejemplos:

TIPO

nombres= arreglo[1..10] de carácter

var

N, M: nombres

Se están declarando dos vectores N y M de 10 elementos cada uno de tipo carácter.

Vemos otro ejemplo que sería con números:

TIPO

Número=arreglo[1..100] de entero

var

NUM: número
Encabezado: Vectores y Matrices 6

Ejemplo de declaración de un arreglo unidimensional o vector en java.

La sintaxis para declarar e inicializar un vector será:

Tipo_de_variable[ ] Nombre_del_array = new Tipo_de_variable[dimensión];

También podemos alternativamente usar esta declaración:

Tipo_de_variable[ ] Nombre_del_array;

Nombre_del_array = new Tipo_de_variable[dimensión];

Sería así:

float [] notas = new float[20];

El tipo de variable que puede ser como:

 byte[ ] edad = new byte[4];

 short[ ] edad = new short[4];

 int[ ] edad = new int[4];

 long[ ] edad = new long[4];

 float[ ] estatura = new float[3];

 double[ ] estatura = new double[3];

 boolean[ ] estado = new boolean[5];

 char[ ] sexo = new char[2];

 String[ ] nombre = new String[2];


Encabezado: Vectores y Matrices 7

Aclarar que los valores por defecto son los siguientes:

a) Para números el valor cero “0”.

b) Para cadenas y letras el valor vacío.

c) Para booleanos el valor false.

Declarar y inicializar un arreglo se hace de la siguiente forma:

TipoDeDato nombre[] = {var1, var2, varn};

Esto crea e inicializa un arreglo de n elementos con valores var1, var2, varn.

Ejemplos:

String edad[] = {10, 20, 40 };

Ingresar Datos

Un vector se maneja a través de posiciones, empezando desde la posición cero y para

obtener/almacenar uno de sus elementos se utiliza un índice (una variable), el índice indica

la posición del elemento en el vector a la que se quiere acceder.

Entonces un vector como el del ejemplo con dimensión 6, efectivamente se puede

almacenar 6 elementos pero solo tendrá 5 posiciones (puesto que se empieza desde la

posición 0) a la cual se puede acceder ya sea para almacenar u obtener

elementos almacenados.

Para almacenar un elemento en un vector se utiliza la siguiente sintaxis:

nombre_vector [indice/posicion]=valor_asignar;

Utilizando el ejemplo anterior podríamos escribir la siguiente sentencia:

miArreglo[1]=7;

Lo que hicimos fue asignar en la posición 1 del vector, el elemento 7.


Encabezado: Vectores y Matrices 8

Búsqueda en un Arreglo Dimensional Java

De las cosas que vamos a necesitar hacer a menudo será realizar búsquedas, ya sea en un

arreglo, en un resultset, listas o lo que sea que almacene datos, por ello deberemos tener a

lado nuestra función de búsqueda. Para realizar búsquedas existen diversos métodos, aquí

solo les doy el ejemplo con el método más sencillo el cual recorre un arreglo hasta

encontrar la posición del primer elemento que coincida con lo que mandamos a buscar.

Como se ve, conviene que el primer parámetro sea el arreglo y el otro sea la cadena a

buscar y deben retornar un entero que sea la posición encontrada.

Para obtener un elemento desde un vector, se realiza de la siguiente forma:

tipo_dato nombre_variable= nombre_vector[indice/posicion];

int valor= miArrreglo[3];

Se está obteniendo el elemento de la posición 3 y se almacena en la variable de tipo

entero llamada valor.

Cuando la dimensión de un arreglo es demasiado grande, se puede llenar o imprimir el

contenido de un vector utilizando un ciclo for.

Ejemplo:

public int getIndiceArray(String[] arr, String cad)

//Aqui pueden usar el método de búsqueda que necesiten.

int index=-1;

for(int i=0;i<arr.length;i++)

{
Encabezado: Vectores y Matrices 9

if(arr[i] == null ? cad == null : arr[i].equals(cad)){

index=i;

break;

return index;

Mostrar el Contenido de un Arreglo en Java

Para listar los elementos de un Array en Java deberemos de conocer la posición de cada

elemento susceptible de ser listado. En el caso de querer listar todos los elementos

del Array tendremos que recorrer, uno a uno, cada uno de los elementos que comprenden

el Array.

Lo primero que tenemos que saber es que para listar un determinado elemento

deberemos de utilizar la siguiente sentencia:

System.out.println(miArray[posicion]);

Para mostrar todos los elementos utilizaremos una estructura repetitiva (por ejemplo el

bucle for). Tendremos que iterar tantas veces como elementos comprendan el Array. Para

saber el número de elementos que contiene el Array utilizamos la propiedad .length.

Al final, nuestro bucle quedaría algo así:

1. for (int x=0; x<miArray.length; x++)

2. System.out.println(miArray[x]);
Encabezado: Vectores y Matrices 10

Operaciones Habituales Con Arrays: Buscar, Añadir, Insertar, Borrar

Algunas operaciones con datos pertenecientes a un array son especialmente frecuentes:

buscar si existe un cierto dato, añadir un dato al final de los existentes, insertar un dato

entre dos que ya hay, borrar uno de los datos almacenados, etc. Por eso, vamos a ver las

pautas básicas para realizar estas operaciones, y una fuente de ejemplo.

Para ver si un dato existe, habrá que recorrer todo el array, comparando el valor

almacenado con el dato que se busca. Puede interesarnos simplemente saber si está o no

(con lo que se podría interrumpir la búsqueda en cuanto aparezca una primera vez) o ver en

qué posiciones se encuentra (para lo que habría que recorrer todo el array). Si el array

estuviera ordenado, se podría buscar de una forma más rápida, pero la veremos más

adelante.

Para poder añadir un dato al final de los ya existentes, necesitamos que el array no esté

completamente lleno, y llevar un contador de cuántas posiciones hay ocupadas, de modo

que seamos capaces de guardar el dato en la primera posición libre.

Para insertar un dato en una cierta posición, los que queden detrás deberán desplazarse

"hacia la derecha" para dejarle hueco. Este movimiento debe empezar desde el final para

que cada dato que se mueve no destruya el que estaba a continuación de él. También habrá

que actualizar el contador, para indicar que queda una posición libre menos.

Si se quiere borrar el dato que hay en una cierta posición, los que estaban a continuación

deberán desplazarse "hacia la izquierda" para que no queden huecos. Como en el caso

anterior, habrá que actualizar el contador, pero ahora para indicar que queda una posición

libre más.
Encabezado: Vectores y Matrices 11

Arreglos Bidimensionales (matrices)

También conocidas como matrices, son un tipo especial de vectores, funcionan de forma

parecida que un vector, de igual forma almacenan elementos de un mismo tipo, el acceso a

sus elementos se lo hace utilizando índices igual que en los vectores.

La diferencia fundamental es que en las matrices se maneja el concepto de fila y

columna y por esa razón se les trabaja de forma diferente.

Como Declarar una Matriz

La declaración de una matriz se la puede hacer con la siguiente sentencia:

tipo_dato nombre_matriz [][]= new tipo_dato [dimension_filas][dimension_columnas];

Declarar una matriz en java:

int miMatriz[][]= new int[5][2]; //ejemplo declaración e inicialización

En donde:

 int es el tipo de dato para los elementos de la matriz, esta matriz sólo puede

almacenar valores de tipo entero.

 [] [] los 2 corchetes le indican al compilador que no estoy declarando una variable,

ni un vector, sino una matriz.

 miMatriz es el nombre que se le da a la matriz, con este nombre podré acceder a su

contenido y utilizar cuantas veces sea necesario.

 el operador = le dice al compilador que ese vector debe apuntar a una zona de

memoria que se va reservar para la matriz.

 la palabra reservada new crea un espacio en memoria para la matriz y la palabra int

le dice que será de tipo entero.


Encabezado: Vectores y Matrices 12

 [5] [2] el número entre corchetes le indica que la dimensión que tendrá la matriz, el

primer corchete indica el número de filas y el segundo corchete indica el número

de columnas; es decir tendrá 5 filas y 2 columnas.

Como Llenar una Matriz

Existen 2 formas de llenar una matriz

La primera es dándole valores al momento de crearla (quemando los elementos), la

sintaxis sería como sigue:

tipo_dato nombre_matriz [][]={{elemento1, elemento2, elemento3},{elemento4,

elemento5,elemento6}};

Ejemplo:

int miMatriz [][] = {{2,5,3},{3,6,9},{0,8,9}};

En el caso anterior hemos declarado y llenado una matriz con elementos fijos, la

dimensión de esta matriz es de 3×3.

La llaves externas definen la matriz, para separar cada fila lo hacemos con llaves{}

internas seguido de una coma (,) .

Para separa las columnas se utiliza una coma (,) después de cada elemento.

La segunda forma es declararla, darle dimensiones y luego llenarla utilizando las

posiciones de acuerdo a la siguiente sintaxis:

nombre_matriz [posfila][poscolumna]=elemento;
Encabezado: Vectores y Matrices 13

Ejemplo:

//llenar la primera fila

miMatriz[0][0]=5;

miMatriz[0][1]=8;

miMatriz[0][2]=1;

//llenar la segunda fila

miMatriz[1][0]=9;

miMatriz[1][1]=7;

miMatriz[1][2]=2;

// llenar la tercera fila

miMatriz[2][0]=10;

miMatriz[2][1]=15;

miMatriz[2][2]=25;

La declaración en inicialización anterior crearía en memoria algo parecido a la siguiente

imagen:
Encabezado: Vectores y Matrices 14

Como podemos observar las matrices al igual que los vectores empiezan desde la

posición cero (0), es por eso que siempre para llenar o acceder a un elemento, debemos

tener en cuenta de no acceder a posiciones que no existen.

La forma anterior que muestra cómo llenar una matriz es un poco tedioso ya que si

fueran muchos elementos tendríamos que repetir líneas de código, una buena forma de

llenar una matriz es hacerlo un poco más dinámico utilizando 2 ciclos for, uno para manejar

las filas y otro para las columnas.

Scanner entrada = new Scanner(System.in);

for (int i = 0; i < miMatriz.length; i++) {

for (int j = 0; j < miMatriz.length; j++) {

System.out.print("Ingrese un elemento: ");

miMatriz[i][j]=entrada.nextInt();

En este caso se ha llenado pidiendo elementos desde la consola, en donde los índices

corresponden a las variables i e j que llenan respectivamente cada posición de la matriz.


Encabezado: Vectores y Matrices 15

Como Acceder a los Elementos de una Matriz

De la misma forma que se puede llenar una matriz utilizando las posiciones vistas en el

ejemplo anterior, también se puede accesar a sus elementos utilizando las posiciones.

tipo_dato variable= nombre_matriz [pos_fila][pos_columna] ;

En el lenguaje de programación java seria:

int var=miMatriz[0][2];

Si continuamos con el ejemplo anterior el valor que se almacena en la variable var es el

número 1, puesto que está en las posiciones fila 0 columna 2 de la matriz.

Otra forma de acceder a los elementos de una matriz es recorrerla utilizando ciclos for,

en este caso vamos a imprimir los elementos de la matriz del ejemplo anterior.

for (int i = 0; i < miMatriz.length; i++) {

for (int j = 0; j < miMatriz.length; j++) {

System.out.print(String.format(" %d ",miMatriz[i][j]));

System.out.println();

}
Encabezado: Vectores y Matrices 16