Trabajo de Luis Fernando

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

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.
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.
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
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];

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.

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++)
{
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]);
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.
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.

 [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;
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:
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.

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();
}

Trabajo de Luis Fernando

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Trabajo de Luis Fernando

Uploaded by

Copyright:

Available Formats

Encabezado: Vectores y Matrices 1

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

Luis Fernando Polo Piñeres

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

Piñeres, Facultad de Ingenieria, Universidad de Cartagena

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

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

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

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

(binarios, árbol-b) y grafos.

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 tres o más dimensión.

Arreglo Unidimensionales o Vectores

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

Para implementar arreglos unidimensionales se debe reservar espacio en memoria.

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:

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

Identificador de la variable: <nombre del tipo arreglo>

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

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:

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:

Nombre_del_array = new Tipo_de_variable[dimensión];

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];

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};

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

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

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