1

Unidad 5- ESTRUCTURAS ESTÁTICAS : Tablas

Desarrollo de la unidad : 24 h
Conceptos:
Tablas unidimensionales, vectores, cadenas, modificación, búsqueda, ordenación, mezclas
Tablas bidimensionales, matrices, tridimensionales
Implementación de pilas y colas

1. MANEJO DE TABLAS: TEORÍA Y ALGORITMOS EN PSEUDOCÓDIGO

( También llamados: array, arreglos )

Introducción

Las tablas también conocidas como array es una estructura de datos muy utilizada, que es empleada en
multitud de algoritmos. Es una estructuras que funciona como contenedor de datos. Un estructura
donde podemos almacenar, guardar, eliminar, buscar o obtener datos. Sin el uso de tablas sería muy
complicado resolver determinados problemas como los siguientes:

 Ordenar 2, 3... N Elementos

 Leer X valores y mostrarlos en orden inverso
 Obtener los X valores más grandes de una serie
 Mostrar el valor que más veces se repite
 Problemas de usan tablas Loto, Quiniela, Tablero de Ajedrez, Matrices, Polinomios,
 Almacenar una frase o una palabra.

Definición de las tablas

Conjunto finito y fijo de elementos de un mismo tipo almacenados en posiciones consecutivas.

Existen algunos lenguajes que permiten tablas que no cumplen esta definición: de tamaño variable
( Problema de asignación de memoria) y de distinto tipo ( Pérdida de eficiencia )

Cada tabla tiene un nombre, tamaño y un tipo de elemento

Ej.- En Pseudocódigo se suele definir de la forma siguiente:
<Tipo de elementos> <Nombre de la tabla> [ <Número de elementos> ]
 En PSEINT se define como:
Entero MiTabla [10]
Dimension Mitabla[10]

20 12 5 12 4 -5 0 32 23 10 ← Valores
1 2 3 4 5 6 7 8 9 10 ← Posiciones

• Los valores de una tabla sólo se pueden modificar elemento a elemento, indicando la posición
del elemento que quiero modificar.

• Para indicar un elemento concreto de una tabla lo expresamos mediante un valor entero que
debe estar entre 1 y N siendo N el tamaño máximo de la tabla.
2
MiTabla [3] = 100
MiTabla [ Num/ 2 + 1 ] = 1000 * Dato

!No se permiten utilizar operaciones básicas que afecten a toda la tabla¡

Leer MiTabla
Mostrar MiTabla
Tabla1 = Tabla2
MiTabla = 0
MiTabla = 23,10,20.....

Sobre los elementos de una tabla se pueden hacer las mismas operaciones que sobre un elemento
básico que forma la tabla:

MiTabla[2] = MiTabla[0] * 12 + valor

Mostrar MiTabla[1]
Leer MiTabla[3]

Existen lenguajes donde se pueden definir el tipo de índices a utilizar: enteros, letras, tipos
enumerados: Ej- ‘A’-‘Z’ , VERDE a ROJO 4-8 y se detecta en ejecución si un índice está fuera de la
tabla. El Lenguaje Java es muy limitado en este aspecto: el índice sólo puede ser un valor entero
entre 0 y N-1 siendo N el tamaño de la tabla, y no puede acceder a una posición fuera de la tabla, si
esto ocurre se produce un error de ejecución. En otros lenguajes (C) esto no se chequea lo que puede
incrementar la rapidez de los programas a cambio de un mayor porcentaje de posibles errores.

Uso de índices
Para recorrer los distintos elementos de una tabla es necesario utilizar una variable entera que tome los
valores 1 a N, esta variable se denomina índice de la tabla.

-- Hay que garantizar que el valor del índice no supera en ningún momento los límites de la tabla

EJEMPLO - Inicializar todos los elementos a 0

Entorno
Entero Mitabla[10]

1) Forma directa

MiTabla[1] <- 0
MiTabla[2] <- 0,
............
MiTabla[10] <- 0;

2) Forma mediante un índice dentro de ciclo PARA

PARA i <- 1 HASTA 10 HACER

MiTabla[i] <- 0
FIN-PARA

El ciclo “PARA” es consustancial con el manejo de las tabla, al ser una estructura de datos de
tamaño fijo. En la mayoría de los casos la mejor forma de manejar una tabla es mediante este ciclo.
3
2. TIPO DE TABLAS
Según el número de índices o coordenadas que debemos utilizar para acceder a un elementos:
- Unidimensionales o Vectores
<Tipo de Elemento> <Nombre Tabla> [ NumMax ]

Real edad[20

18 19 21 .. 20 18 18
edad[0] edad[1] edad[2] edad[17] edad[18] edad[19]

- Bidimensionales o Matrices
<Tipo de Elemento> <Nombre Tabla> [ NumMax1, NumMax2 ]
Real notas[25,3]

NOTAS NOTAS NOTAS

DEL DEL DEL
MÓDULO MÓDULO MÓDULO
SIMM PLE ANÁLISIS
Notas del primer alumno 5 7 8
Notas del segundo alumno 8 7 6
Notas del tercer alumno 6 5 7
Notas del cuarto alumno 5 5 5
...... ... .. ...
Notas del 25º alumno 5 9 8

notas[4,2]

- Multidimensionales o poliedros
<Tipo> <Nombre> [ N1,N2,N3]
Entero Cubo [3,5,2]

ALMACENAMIENTO EN MEMORIA

Las tabla se almacenan en la memoria del ordenador siguiendo posiciones consecutivas a partir de una
posición inicial donde comienza la tabla. El tamaño ocupado por una tabla estará en función de tamaño
de los elementos que almacena y del número de ellos, cuyo valor dependerá de la dimensiones de la
tabla.

Unidimensionales

Dirección de Tabla [ i ] = DirBase + Tamaño del Elemento * ( I –1 )

Si la primera posición de memoria de una tabla es la 23002, ¿en qué posición de memoria estaría el
valor Tabla[5], sabiendo que los número enteros ocupan 4 bytes?
Dir(3) = 23002 + (5-1)*4 = 230018

Bidimensionales
Dir ( I , J ) = DirBase + Tamaño del Elemento * ( Ncolumnas * (I –1 ) + (J –1) )
Dir ( I , J ) = DirBase + Tamaño del Elemento * ( NFilas * (J –1) + (I –1) )
4
3. ALGORITMOS BÁSICOS SOBRE TABLAS UNIDIMENSIONALES O VECTORES

1.- Rellenar con valores en la entrada

Mostrar “ Introduce los valores : “

PARA I = 1 HASTA N HACER
Mostrar “ Introducir valor para el elemento Nº “, I
Leer Tabla [ I ]
FIN-PARA

2.- Mostrar tabla

Mostrar “ Contenido de la tabla: “
PARA I = 1 HASTA N HACER
Mostrar “ Valor para el elemento Nº “, I, “=”, Tabla [ I ]
FIN-PARA

3. - Recorrer una tabla y sumar sus valores

Suma = 0
PARA I = 1 HASTA N HACER
Suma = Suma + Tabla [ I ]
FIN-PARA

4.- Calcular el máximo de una tabla de enteros

máximo = Tabla[1] // Máximo provisional
PARA I = 2 HASTA N HACER
SI ( Tabla [ I ] > máximo ) ENTONCES
máximo = Tabla [ I ]
FIN-SI
FIN-PARA
Mostrar “ El valor más grande de la tabla es “, máximo

5.- Invertir una tabla

// Si almacena 20, 12, 4, 8, 213 cambia a -> 213 ,8 ,4 , 12, 20
// Tengo que hacer N/2 Intercambios 20 ↔213 12 ↔ 8

PARA I = 1 HASTA N/2

aux = Tabla [ I ]
Tabla [ I ] = Tabla [ N – ( I - 1 ) ]
Tabla [ N – ( I – 1) ] = aux
FIN-PARA

6.- Calcular la Moda : El valor que más veces se repite en una tabla
// Este algoritmo se puede mejorar

FModa = 0 // Frecuencia del número que más veces se repite

PARA I = 1 HASTA N HACER
fmodatmp = 0 // Frecuencia del número actual
Valor = Tabla [ I ] // Valor de la posible moda
// Calcula cuantas veces se repite el candidato a ser moda
PARA J = 1 HASTA N HACER
SI ( Tabla [ J ] = Valor )
ENTONCES
FModaTmp = FmodaTmp + 1
FIN-SI
FIN-PARA
// Si se repite más veces, es la nueva moda
SI ( FmodaTmp > FModa )
FModa = FmodaTmp
Moda = Valor
FIN-SI
FIN-PARA
Mostrar Moda
5
4. TABLAS EN JAVA

Declaración de tablas:
Se indica el tipo con unos corchetes para señalar que es una tabla. Si no fijamos su tamaño la tabla
tiene un valor nulo por lo que no se puede acceder a sus valores. Para hacerlo tenemos que crear la
tabla con un tamaño determinado o bien indicarle que valores iniciales va a tener.
// Definición de una tabla sin tamaño
int notasAsir[];

notasAsir = new int[5]; // Reservo un espacio determinada para cada tabla

// Lo normal es hacerlo en un paso

int notasSmr[] = new int[5];

// Defino una tabla asignado valores iniciales

int [] notasDaw = {5,6,7,8,5,3}; //En la definición los [] pueden estar antes o después del nombre.

Recorrido:
Se utiliza un indice entero desde 0 hasta el tamaño de la tabla N-1. En todo momento podemos conocer
el tamaño de la tabla preguntando por el atributo nombretabla.length.

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

mitabla[i] = 0;
}

En Java como en muchos otros lenguajes

la primera posición de la tabla
es la posición 0

Ciclo for-each
Java permite recorrer una tabla como si fuera una colección de objetos para ello utiliza un ciclo for
especial denominado for-each, que recorre toda la tabla obteniendo cada uno de los valores del la tabla.
Este ciclo nos permite recorrer otros tipos de estructuras más complejas (Ej- Listas, tablas hash…) Este
ciclo solo vale para obtener valores no para modificarlos.

// Recorro la tabla con el for tipo foreach

// el valor debe ser del tipo de dato que tenga la tabla
// Ej.- valor es entero porque la tabla es de enteros
int suma =0;

for(int valor : notasDaw){

suma = suma + valor;
}
System.out.println("Media =" + suma/notasDaw.length);

Las tablas con más de una dimensión se definen con varios corchetes
int matriz [] [] = new int [4][10];
En Java, el índice de la primera posición siempre es siempre 0, por lo que matriz[0][0]
será el primer elemento de la matriz.
- El tamaño del array puede obtenerse utilizando la propiedad nombredetabla.length:
matriz.length nos da el número de filas
matriz[0].length nos da el número de columnas de la primera fila.
En Java las tablas cada fila puede tener distinto número de columnas.
6
5. ALGORITMOS BÁSICOS SOBRE TABLAS UNIDIMENSIONALES EN JAVA
1.- Rellenar con valores en la entrada.
System.out.println("Introduce los valores :");
for (int i=0; i< vector.length; i++){
System.out.printf(" Introducir valor para el elemento Nº %2d:", i);
vector[i] = sc.nextInt();
}

2.- Mostrar tabla.

System.out.println(" Contenido de la Tabla:");
for (int i = 0; i <vector.length; i++){
System.out.println(" Valor para el elemento Nº "+ i +"= "+vector[i]);
}

3. - Recorrer una tabla y sumar sus valores.

public static int sumarTabla( int [] vector){
int suma = 0; // Utilizo un ciclo for-each
for ( int valor: vector){
suma += valor;
}
return suma;
}

4.- Calcular el máximo de una tabla de enteros.

public static int maximoDeTabla (int [] vector){
int maximo = vector[0];
for (int i=1; i< vector.length; i++){
if ( vector[i] > maximo ){
maximo = vector[i];
}
}
return maximo;
}

5.- Invertir una tabla.

public static void invertirTabla (int [] vector){

int aux;
for (int i=0; i< vector.length/2 ; i++){
aux = vector[i];
vector[i] = vector[vector.length - i-1];
vector[vector.length - (i+1)] = aux;
}
}

5.- Calcular la Moda : El valor que más veces se repite en una tabla.
public static int calcularModa ( int [] vector ){
int moda, fmoda, valor, fmodatmp ;

fmoda = 0; moda = 0;
for (int i=0; i < vector.length; i++){
fmodatmp = 0;
valor = vector[i];// Calculo cuantas veces se repite ese valor
for (int j=0; j < vector.length; j++){
if ( vector[j]== valor ) fmodatmp++;
}
if( fmodatmp > fmoda){ // Si se repite más, es la nueva moda
fmoda = fmodatmp;
moda = valor;
}
}
return moda;
}
7

6. MÉTODOS DE BÚSQUEDA DE UN ELEMENTO EN UNA TABLA

Una de las operaciones más habituales en un array es la búsqueda de un determinado valor. Hay que
tener presente si la tabla está ordenado o no. En caso que esté ordenada el método más eficiente es el
denominado búsqueda dicotómica o binaria.

1. Búsqueda secuencial tabla no ordenada.

Número medio de elementos recorridos ( Número de elementos / 2)
I=1
Encontrado = falso
// Salimos si lo encontramos o si llegamos al final de la tabla.
MIENTRAS ( NOT Encontrado AND ( I < = N ) )
SI ( Tabla [ i ] = Valor )
Encontrado = cierto
SINO
I = I + 1
FIN-SI
FIN-MIENTRAS

SI Encontrado = cierto
Mostrar “ El Elemento está en la tabla en la posición“,I
SINO
Mostrar “El Elemento no está en la tabla “
FINSI

-3 -1 0 2 4 5 10 16 18 20 23 24 32 36 43

B) Otra forma menos estructurada con salida del for ( break del lenguaje Java)

Encontrado = falso
PARA I = 1 HASTA N HACER
SI ( Tabla [ i ] = Valor )
Encontrado = cierto
SALIR DEL CICLO PARA (BREAK)
FIN-SI
FIN- PARA

SI Encontrado = cierto
Mostrar “ El Elemento está en la tabla en la posición“,I
SINO
Mostrar “El Elemento no está en la tabla “
FINSI

-3 -1 0 2 4 5 10 16 18 20 23 24 32 36 43
8

2. Búsqueda secuencial en una tabla ordenada

En el caso que encontremos un valor superior al buscado, ya sabemos que el elemento no aparece
en la tabla.

A) CON MIENTRAS
B) CON REPETIR
I = 1
Terminar = NO I = 0
MIENTRAS ( Terminar = NO AND ( I <= N ) ) Terminar = NO
SI ( Tabla [ i ] >= Valor ) REPETIR
Terminar = SI I = I + 1
SINO SI (Tabla [ I ] > = Valor )
I = I + 1 Terminar = SI
FIN-SI FIN-SI
FIN-MIENTRAS HASTA ( Terminar = SI ) OR ( I = N)

SI ( Terminar ) SI ( Terminar )
SI ( Tabla [ I ] = Valor ) SI ( Tabla [ I ] = valor )
Mostrar “ Está en la posición “,I Mostrar “ Está en la posición “,I
FIN-SI FIN-SI
SINO SINO
Mostrar “ No está en la tabla “ Mostrar “ No está en la tabla “
FINSI FIN-SI

-3 -1 0 2 4 5 10 16 18 20 23 24 32 36 43

En esta caso cuando salimos no sabemos si es por que hemos encontrado el valor o porque hemos
encontrado un valor superior.

IMPLEMENTACIÓN EN JAVA DE LA BÚSQUEDA SECUENCIAL

Codificamos un método que tiene dos parámetros: la tabla y el valor que queremos buscar y devuelve
la posición del elemento o -1 que indica que no lo ha encontrado

public static int buscarSecuencial ( int [] vector, int valor ){

int pos = -1; // Supongo que no está

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

if ( valor == vector[i]){
pos = i; // Guardo la posición y salgo del ciclo
break;
}
}
return pos;
}

// Podríamos utilizar este método

. . .
posicion = buscarSecuencial(tabla, 23);
if (posicion == -1) {
System.out.println("No se encuentra");
} else {
System.out.println("El valor está en la posición:" + posicion);
}
9

3.- Búsqueda dicotómica o binaria

Cuando la tabla está ordenada este es un método mucho más eficiente.

Máximo número de posiciones recorridas mediante búsqueda binaria en una tabla de N elementos:
Log 2 N + 1
Siempre que tengamos que realizar una búsqueda en una tabla ordenada debemos utilizar este
método al ser mucho más eficiente que la búsqueda secuencial.

Ejemplo sobre una tabla de 1024 Posiciones

● Búsqueda secuencial:
Número medio de posiciones recorridas 1024 / 2 → 512 posiciones
● Búsqueda dicotómica:
Número máximo de posiciones recorridas Log 2 1024 + 1 = 11 posiciones

ALGORITMO:
// Me situó en mitad de la tabla y decido si tengo que continuar por la derecha o por la izquierda
Izda = 1
Dcha = N
Encontrado = NO
MIENTRAS ( Izda <= Dcha ) and ( NOT Encontrado )
Medio = ( Izda + Dcha ) / 2
SI ( Tabla [ Medio ] = Valor )
Encontrado = SI
SINO
SI ( Tabla [Medio] < Valor )
Izda = Medio + 1
SINO
Dcha = Medio – 1
FIN-SI
FIN-SI
FIN-MIENTRAS

SI ( Encontrado )
Mostrar “ El elemento se encuentra en la posición “, Medio
SINO
Mostrar “ El elemento no aparece en la tabla.”
FIN-SI

-3 -1 0 2 4 5 10 16 18 20 23 24 32 36 43
10
7. MÉTODOS DE ORDENACIÓN

Una de la operaciones más comunes que realiza un sistema informático es la ordenación de datos, (de
ahí proviene la palabra de origen francés ordenador), la ordenación de tablas es fundamental en la
mayoría de las ocasiones para realizar un manejo eficiente de las mismas. Existen varios algoritmos de
ordenación siendo los métodos más conocidos los siguientes:

A) Intercambio directo ( Burbuja ), compara cada dos elementos y si no están ordenados los
intercambia, repite tantas veces como elementos.

PARA I = 1 HASTA N - 1
PARA J = 1 HASTA N - I
SI TABLA [ J ] > TABLA [ J + 1 ]
AUX = TABLA [J] 7 5 1 2 4
TABLA [J] = TABLA[J +1] 5 1 2 4 7
TABLA [J +1] = AUX 1 2 4 5 7
FIN-SI 1 2 4 5 7
FIN-PARA 1 2 4 5 7
FIN-PARA

Mejoras:
- No seguir si no ha habido ningún intercambio
- Hacer una pasada en un sentido y otro en otro
- No recorrer la parte ordenada

Versión mejorada que termina cuando no se produce ningún intercambio:

Cambio = SI
I = 1 A  pesar  de  estás  mejoras  el 
MIENTRAS ( Cambio = SI ) método  de  intercambio  directo  es  uno 
Cambio = NO de  los  métodos  de  ordenación  más 
PARA J = 1 HASTA N - I
SI TABLA [ J ] > TABLA [ J + 1 ]
lentos,  debido  a  que  desplaza  los 
AUX = TABLA [J] elementos desordenados  una posición 
TABLA [J] = TABLA[J +1] cada vez.
TABLA [J +1] = AUX
Cambio = SI
FIN-SI
FIN-PARA
I = I + 1
FIN-MIENTRAS
11

B ) Selección directa, Buscar el más pequeño de la parte desordenada y lo sitúa al final de la

parte ordenada, Intercambiando su posición

PARA I = 1 HASTA N – 1
PosM= I
Mínimo = Tabla [ I ]
PARA J = I +1 HASTA N
SI ( Mínimo > Tabla [ j ] )
Mínimo = Tabla [ j ] 7 5 1 2 4
PosM= J 1 5 7 2 4
FIN-SI 1 2 7 5 4
FIN-PARA 1 2 4 5 7
/* Sólo si no esta en su sitio correcto lo intercambio */ 1 2 4 5 7
SI ( PosM ≠ I )
Tabla [ PosM ] = Tabla [ I ]
Tabla [ I ] = Mínimo
FINSI
FIN-PARA

C) Inserción directa, Coge el primer elemento de la parte desordenada y lo sitúa en la posición

correcta de la parte ordenada. ( Método de la baraja )

PARA I = 2 HASTA N
aux = Tabla [ I ]
J= I-1
MIENTRAS ( Tabla [ J ] > aux ) and ( J > 1 )
Tabla [ J + 1 ] = Tabla [ J ]
J = J –1
FIN-MIENTRAS
SI ( Tabla [ J ] > aux )
Tabla [ J + 1 ] = Tabla [ J ]
Tabla [ J ] = aux
SINO
Tabla [ J + 1 ] = aux
FINPARA

Mejora: Inserción Binaria, busca la posición a insertar

mediante la búsqueda dicotómica o binaria al estar esa parte
de la tabla ordenada.

7 5 1 2 4
5 7 1 2 4
1 5 7 2 4
1 2 5 7 4
1 2 4 5 7
D) Rápido (Quicksort ): Nos situarnos en la mitad de la parte desordenada y intercambiar
mayores a un lado y menores al otro, volvemos hacer lo mismo con cada una de las mitades
mediante llamadas recursivas.

Entero Tabla [ N ] /* Variable Global */

PROCEDIMIENTO Quicksort ( entero Inicial, entero Final , entero Tabla[])

ENTORNO
Entero Izda, Dcha
Entero Aux, Maux
Izda = Inicial
Dcha = Final
Maux = Tabla [ ( Izda + Dcha) / 2 ]
REPETIR
MIENTRAS (Tabla[Izda] < Maux)
Izda = Izda +1
FIN-MIENTRAS
MIENTRAS ( Tabla[Dcha] > Maux )
Dcha = Dcha + 1
FIN-MIENTRAS
SI ( Izda <= Dcha )
aux = Tabla [Izda]
Tabla[Izda] = Tabla [Dcha]
Tabla[Dcha] = aux El quicksort es con diferencia el mejor método de
Izda = Izda + 1 ordenación. Suelen existir librería en la mayor
Dcha = Dcha -1 parte de los lenguajes que permite ordenar
FINSI cualquier tipo de tabla utilizando este algoritmo.
HASTA ( Izda > Dcha )
SI ( Inicio < Dcha )
Quicksort ( Inicio, Dcha, Tabla )
FINSI
SI ( Final > Izda )
Quicksort ( Izda, Final, Tabla)
FINSI
FIN-PROCEDIMIENTO

Llamada desde el programa principal :

Quicksort ( 1, N )
...

12
8. ALGORITMOS SOBRE VARIAS TABLAS

Es muy habitual que un programa trabaje con varias tablas: que tenga que pasar información de un
tabla a otra, completar datos de una con el resumen de la otra, eliminar datos que aparecen en uno y
no en la otra, etc. Uno de los más comunes tanto para tablas como para otro tipo de contenedores es
el algoritmos de mezcla de dos tablas ordenadas.

Algoritmo de mezcla: Copiar en un tabla TR, el contenido de dos tablas ordenadas T1, T2
T1
2 8 10 21 103

TR
Mezcla 2 3 7 8 10 13 21 31 90 98 103 121

T2
3 7 13 31 90 98 121

PROCEDIMIENTO Mezclar ( Entero t1[](E), Entero t2[] (E), Entero tr[](S), int lim1(E), int
lim2(E))
ENTORNO
Entero i, j ,k
INICIO
i=1
j=1
k=1
/* Mezclo ambas tablas */
MIENTRAS ( ( i <= lim1) AND ( j <= lim2) )
SI ( t1[ i ] < t2 [ j ] )
tr [ k ] = t1 [ i ]
i=i+1
SINO
tr [ k ] = t2 [ j ];
j=j+1
FIN-SI
k=k+1
FIN-MIENTRAS
/* Copio el resto */
MIENTRAS ( i <= lim1 )
tr [k] = t1[i];
i = i +1
k=k+1
FIN-MIENTRAS
/* Copio el resto */
MIENTRAS ( j <= lim2 )
tr [k] = t2[j];
j=j+1
k=k+1
FIN-MIENTRAS
FIN-PROCEMIENTO

13
Implementación en Java de la Mezcla de dos tablas.

public static int [] mezclaTablas ( int t1[], int t2[]){

// Creo la tabla resultante
int tr[] = new int [ t1.length + t2.length];
int i = 0;
int j = 0;
int k = 0;
// Hay datos de la dos tablas
while ( i < t1.length && j < t2.length){
if ( t1[i] < t2[j]){
tr[k] = t1[i];
i++;
}
else {
tr[k] = t2[j];
j++;
}
k++;
}

// Copio lo que queda de t1 o de t2

while ( i < t1.length){
tr[k] = t1[i];
i++;
k++;
}
while ( j < t2.length){
tr[k] = t2[j];
j++;
k++;
}

return tr;
}

Otro ejemplo: Suma el valor de dos tablas guardando el resultado en una tercera. Si no son del
mismo tamaño se supone que el valor será cero en la posiciones que faltan

n1 → [11, 15, 16, 27, 28, 28]

n2 → [15, 17, 17, 20, 24, 25, 27, 31, 32, 32]
Suma →[26, 32, 33, 47, 52, 53, 27, 31, 32, 32]

public static int[] sumaTablas ( int t1[], int t2[]){

int tsuma[];
// Obtengo el tamaño más grande
int tamaño = ( t1.length > t2.length)? t1.length: t2.length;
tsuma = new int[tamaño];
for (int i=0; i < tamaño; i++){
int suma =0;
if ( i < t1.length){
suma += t1[i];
}
if ( i < t2.length){
suma += t2[i];
}
tsuma[i] = suma;
}
return tsuma;
}

14
9. ALGORITMOS SOBRE MATRICES ( TABLAS BIDIMENSIONALES)

Normalmente cuando trabajamos con una tabla de N dimensiones debemos utilizar N ciclos
anidados ( PARA o MIENTRAS ) para buscar o recorrer la misma.

Ejemplo 1: Inicializar todo los elemento de una matriz a cero.

Entorno
entero Matriz [10,4 ]
entero I, J /* El indice I indica la fila y el índice J indica la columna */
INICIO
PARA I= 1 HASTA 10
PARA J= 1 HASTA 4
Matriz[I,J] = 0
FIN-PARA
FIN-PARA
FIN

Ejemplo 2: Buscar e indicar en que posición está un valor dentro de una tabla bidimensional

ENTORNO
entero Matriz [10,4 ]
entero I, J /* El indice I indica la fila y el índice J indica la columna */
entero Valor /* Valor a buscar en la Matriz */
Lógico encontrado
INICIO
Encontrado = NO
Mostrar “ Introducir el valor a buscar “
Leer Valor
I=1
MIENTRAS ( Encontrado = NO ) and ( I <= 10 )
J=1
MIENTRAS ( Encontrado = NO ) and ( J <= 4 )
SI ( Valor = Matriz [I,J] )
Mostrar “ El elemento se encuentra en la Fila “, I, “ Columna” , J
Encontrado = SI
SINO
J= J +1
FIN-SI
FIN-MIENTRAS
I=I+1
FIN-MIENTRAS
SI ( Encontrado = NO )
Mostrar “ El valor no se encuentra en la Matriz “
FIN-SI
FIN

15
Ejemplo 3: Acumular en una tabla unidimensional la suma de todas las columnas de una tabla
bidimensional

Matriz [5, 4 ]
Entero I,J,K
10 3 4 5 INICIO
2 4 6 7 /* Recorro por columnas */
10 5 6 7 PARA J = 1 HASTA 4
8 9 10 3 Suma [ J ] = 0
3 1 0 3 PARA I = 1 HASTA 5
Suma [ J] = Suma [ J ] + Matriz [ I, J ]
Tabla Suma [ 4 ] FIN-PARA
33 22 26 25 FIN-PARA

Ejemplo 4: Indicar cuando una Matriz de N x N es simétrica. Suponemos que una matriz es
simétrica cuando cualquier elemento en una posición I,J es igual al de la posición J,I.

1 3 8 7 FUNCION EsSimetrica ( Entero Matriz [ , ], Entero N ) Devuelve Lógico

3 4 5 9 Entorno
8 5 6 10 Lógico Resultado
Inicio
7 9 10 3 Resultado = Cierto
/* Sólo pregunto si los elementos debajo de la diagonal son iguale a los de
arriba */
PARA I = 2 HASTA N
PARA J = 1 HASTA I – 1
SI ( Matriz [I,J ]  Matriz [ J, I ] )
Resultado = Falso
FIN-SI
FIN-PARA
FIN-PARA
RETURN Resultado
FIN

16
Ejemplo 5: Tenemos una tabla de 3 x 3 con los valores enumerados Rojo, Azul y Libre, que
representan el estado de una partida de tres en raya. Indicar si las fichas Rojas han ganado la
partida
ROJO ROJO AZUL
ROJO AZUL LIBRE
ROJO LIBRE LIBRE

Ganador = Falso
/* Compruebo primero filas y columnas */
PARA I = 1 HASTA 3
SI ( (T [ I, 1 ] = ROJO ) AND ( T [ I, 2 ] = ROJO ) AND ( T[ I, 3 ] = ROJO ) ) OR
(T [ 1, I ] = ROJO ) AND ( T [ 2, I ] = ROJO ) AND ( T[ 3, I ] = ROJO ) )
Ganador = Cierto
FIN-SI
FIN-PARA
/* Compruebo diagonales */
SI ( (T [ 1, 1 ] = ROJO ) AND ( T [ 2, 2 ] = ROJO ) AND ( T[ 3, 3 ] = ROJO ) ) OR
(T [ 1, 3 ] = ROJO ) AND ( T [ 2, 2 ] = ROJO ) AND ( T[ 3, 1 ] = ROJO ) )
Ganador = Cierto
FIN-SI

17
EJEMPLOS EN JAVA
Ejemplo 1: Inicializar todo los elemento de una matriz a cero.

public static void rellenarMatrizcon0 ( int [][] matriz){

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

for (int j=0; j< matriz[i].length; j++){
matriz [i][j] = 0;
}
}
}

Ejemplo 2: Buscar e indicar en que posición está un valor dentro de una tabla bidimensional

System.out.print("Introduce un valor a buscar:");

int valor = sc.nextInt();

boolean encontrado = false;

int i=0,j=0; // Los defino fuera del ciclo for para poder obtener su valor fuera

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

for (j=0; j< cifras[i].length; j++)
if ( valor == cifras[i][j]){
encontrado = true;
break; // Salgo de este ciclo
}
if (encontrado) break; // Saldo de este ciclo
}
if ( encontrado) System.out.printf("El elemento está en la posición :[%d][%d]\n",i,j);
else System.out.println("El elemento no se encuentra.");

Ejemplo 3: Acumular en una tabla unidimensional la suma de todas las columnas de una tabla bidimensional

// SUMA DE LOS ELEMENTOS DE LA MATRIZ

// Creo un vector con el número de columnas de la matriz cifras
int [] vsuma = new int [cifras[0].length];

for (int columna=0; columna < vsuma.length; columna++){

vsuma[columna] = 0;
for (int fila = 0; fila< cifras.length; fila++ ){
vsuma[columna] = vsuma[columna] + cifras[fila][columna];
}
}

18
Ejemplo 4: Indicar cuando una Matriz de N x N es simétrica. Suponemos que una matriz es simétrica cuando cualquier
elemento en una posición I,J es igual al de la posición J,I.

public static boolean esSimetrica ( int [][] matriz){

boolean resultado = true;
/* Sólo pregunto si los elementos debajo de la diagonal
son iguales a los de arriba */
for (int i=1; i< matriz.length;i ++){
for (int j = 0; j < i; j++){
if ( matriz[i][j] != matriz[j][i]){
resultado = false;
break;
}
}
}
return resultado;
}
Ejemplo 5: Tenemos una tabla de 3 x 3 con los valores enumerados Rojo, Azul y Libre, que representan el estado de
una partida de tres en raya. Indicar si las fichas Rojas han ganado la partida

public class EjemploTresEnRaya {

// Defino un tipo enumerado con los tres valores posibles
enum Fichas { ROJO,AZUL,LIBRE};

static public void main ( String []argv){

// Creo una matriz con un estado de la partida.

Fichas tablero [][] = { {Fichas.ROJO, Fichas.ROJO, Fichas.AZUL },
{Fichas.ROJO, Fichas.AZUL, Fichas.LIBRE},
{Fichas.ROJO, Fichas.LIBRE,Fichas.LIBRE}
};
// Compruebo si las rojas ganan
if ( esGanador( tablero, Fichas.ROJO)) System.out.println(" ROJO GANADOR");
else System.out.println(" ROJO NO GANADOR");

public static boolean esGanador ( Fichas t[][], Fichas color){

// Compruebo filas y columnas

for (int i=0; i < 3; i++){
if ( ( t[i][0] == color) && (t[i][1] == color) && (t[i][2] == color) ||
( t[0][i] == color) && (t[1][i] == color) && (t[2][i] == color) )
return true; // Ganador
}
// Compruebo diagonales
if ( ( t[0][0] == color) && (t[1][1] == color) && (t[2][2] == color) ||
( t[0][2] == color) && (t[1][1] == color) && (t[2][0] == color) ){
return true; // Ganador
}
// Si no ha terminado es que no es ganador
return false;
}

19
En Java se puede definir una matriz indicando solamente el número de filas y posteriormente se le asigna el espacio de
cada fila. También se puede asigna un vector con un tamaño ya definido. Internamente cada fila tiene un puntero a sus
valores.

int resultados[][] = new int[3][];

int tvalores1[] = { 10,23,45};
int tvalores2[] = { 8, 134,12, 5, 1003, 4534};

resultados[0] = new int [2];

resultados[0][0] = 123;
resultados[0][1] = 20;
resultados[1] = tvalores1;
resultados[2] = tvalores2;

La tabla creada tendría los siguientes valores

resultador[0]→ 123, 20,
resultador[1]→ 10, 23, 45,
resultador[2]→ 8, 134, 12, 5, 1003, 4534,

Ejemplo: Obtener una matriz a partir de un vector donde en la primera fila se guarden los valores pares y en la segunda
los valores impares.
/**
* Recibe como parámetro un array y genera una tabla con dos filas, una de pares
* y otra de impares
*
* @vector - array de enteros
* @return - tabla con pares en una primera fila e impares en la segunda
*/
public static int[][] separaParImpar(int vector [])
{
int resu [][];
// Creo una matriz con dos filas vacias
resu = new int [2][];
int contpares = 0;
int contimpares = 0;
// Cuento el numero de pares/impares para calcular el tamaño
for (int valor: vector){
if ( valor % 2 == 0) contpares++;
else contimpares++;
}
// Asigno a cada fila su tamaño correspondiente
resu[0] = new int [contpares];
resu[1] = new int [contimpares];
int idexpares =0;
int ideximpares =0;
for (int valor: vector){
if ( valor % 2 == 0) {
resu[0][idexpares++] = valor;
}
else {
resu[1][ideximpares++] = valor;
}
}

return resu;
}
}

20
10. MÉTODOS PREDEFINIDOS EN JAVA SOBRE TABLAS: paquete java.util.Array
La clase de Java Array incluye un gran número de métodos estáticos que se pueden utilizar fácilmente para resolver las
operaciones más habituales sobre vectores ( tablas unidimensionales). Siempre es preferible utilizar métodos de las
librerías estándar de Java que no reinventar la rueda.

Método Utilidad
Arrays.binarySearch(v, k) Busca el valor k dentro del vector v (que previamente ha de estar ordenado).
Devuelve al posición o un valor negativo con la posición correspondiente donde debería
insertarse.
Arrays.sort(v) Ordena los elementos del vector de menor a mayor
Arrays.equals(v1,v2) Comprueba si dos vectores son iguales.
Arrays.fill(v,val) Rellena un vector con el valor indicado (val)
Arrays.toString(v) Devuelve una cadena con la lista de contiene la tabla.
Arrays.copyOf(v,n) Devuelve una tabla nueva donde copia n elementos de tabla v
Arrays.copyOfRange(v,n1,n2) Devuelve una tabla nueva donde copia desde la posición n1 a la n2 de la tabla v
Consultar más detalles en:
https://www.tutorialspoint.com/java/util/java_util_arrays.htm
https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html
EJEMPLO:

import java.util.Arrays;

public class PruebaArray {

public static void main (String args[]) {

// Creo una tabla de 20 enteros

int [] mitabla = new int [20];

// Relleno la tabla con el valor 5

Arrays.fill(mitabla,5);

// Muestro el contenido de la tabla

System.out.println(" Contenido de la tabla:1 "+Arrays.toString(mitabla));

// Relleno la tabla con valores aleatorios

for (int i=0;i< mitabla.length; i++){
mitabla[i] = (int) (Math.random()*10.0)+1; // Asigno valores entre 1 a 10
}

// Muestro el contenido de la tabla

System.out.println(" Contenido de la tabla:2 "+Arrays.toString(mitabla));

// Ordeno la tabla
Arrays.sort(mitabla);

// Muestro el contenido de la tabla

System.out.println(" Contenido de la tabla:3 "+Arrays.toString(mitabla));

// Busco valores
System.out.println(" ¿Está el 5? = " + Arrays.binarySearch(mitabla, 5));
System.out.println(" ¿Está el 3? = " + Arrays.binarySearch(mitabla, 3));
System.out.println(" ¿Está el 27? = " + Arrays.binarySearch(mitabla, 27));
System.out.println(" ¿Está el -42? = " + Arrays.binarySearch(mitabla,-42));
}
}

21