Guía Académica

de Aprendizaje II
CONTENIDO
Índice de figuras ................................................................................................................................................iv
Introducción........................................................................................................................................................v
1 Recursividad............................................................................................................................................... 6
1.1.1 Atributos y métodos estáticos ................................................................................................... 7
1.1.2 Recursividad. Métodos recursivos ............................................................................................. 8
1.2 Actividades de reflexión y aplicación............................................................................................... 13
2 Clase Vector ............................................................................................................................................. 14
2.1 Definición de una clase .................................................................................................................... 15
2.1.1 Clase Vector ............................................................................................................................. 15
2.2 Actividades de reflexión y aplicación............................................................................................... 18
3 Métodos de ordenamiento ..................................................................................................................... 20
3.1 Ordenamiento ................................................................................................................................. 21
3.1.1 Ordenamiento Burbuja (Bubble sort) ...................................................................................... 21
3.1.2 Ordenamiento por inserción ................................................................................................... 22
3.1.3 Ordenamiento por selección ................................................................................................... 23
3.1.4 Quick sort ................................................................................................................................. 24
3.1.5 Shell ......................................................................................................................................... 24
3.1.6 Ordenación por mezcla o merge sort (combinación) .............................................................. 24
3.2 Actividades de reflexión y aplicación............................................................................................... 25
4 Métodos de búsqueda ............................................................................................................................. 26
4.1 Búsqueda ......................................................................................................................................... 27
4.1.1 Búsqueda secuencial - Análisis ................................................................................................ 27
4.1.2 Búsqueda binaria ..................................................................................................................... 28
4.1.3 Algoritmos de búsqueda recursiva .......................................................................................... 28
4.1.4 Búsqueda mediante transformación de claves (hashing) ....................................................... 29
4.1.5 Colisiones ................................................................................................................................. 32
4.2 Actividades de reflexión y aplicación............................................................................................... 32
5 Clase Arrays ............................................................................................................................................. 34
5.1 Clase Arrays ..................................................................................................................................... 34
5.2 Actividades de reflexión y aplicación............................................................................................... 37
6 Colecciones - conjuntos y listas ............................................................................................................... 38
6.1 Introducción..................................................................................................................................... 39
6.2 Collection ......................................................................................................................................... 39
6.3 Interfaz Iterator ............................................................................................................................... 40

ii
 6.4 Interfaz Set .......................................................................................................................................41
6.5 Interfaz List .......................................................................................................................................42
6.6 Actividades de reflexión y aplicación ...............................................................................................44
7 Mapas .......................................................................................................................................................46
7.1 Interfaz Map .....................................................................................................................................46
7.2 Actividades de reflexión y aplicación ...............................................................................................49

iii
ÍNDICE DE FIGURAS

Fig. 1 Juego de Torres de Hanoi ......................................................................................................................... 6

Fig. 2 Representación UML de atributos y métodos estáticos .......................................................................... 7

Fig. 3 Método de Euclides para encontrar el MCD de dos números ................................................................. 9

Fig. 4 Llamada recursiva para el ejemplo del método factorial () ................................................................... 10

Fig. 5 Método recursivo ................................................................................................................................... 11

Fig. 6 Ejemplo de método recursivo directo.................................................................................................... 11

Fig. 7 Ejemplo de método recursivo indirecto ................................................................................................. 12

Fig. 8 Define la clase Vector ............................................................................................................................. 15

Fig. 9 Agrega atributos a la clase Vector.......................................................................................................... 15

Fig. 10 Método generar Vector para la clase Vector ....................................................................................... 15

Fig. 11 Método mostrar para la clase Vector .................................................................................................. 16

Fig. 12 Método constructor para la clase Vector ............................................................................................ 16

Fig. 13 Prueba de la clase Vector ..................................................................................................................... 17

Fig. 14 Clase Vector ......................................................................................................................................... 17

Fig. 15 Clase Matriz .......................................................................................................................................... 18

Fig. 16 Representación de una Funciones hash............................................................................................... 30

Fig. 61 Ejemplo de colisiones ........................................................................................................................... 30

Fig. 18 Interfaz Collection ................................................................................................................................ 39

Fig. 19 Interfaz Iterator .................................................................................................................................... 41

Fig. 20 Interfaz Set ........................................................................................................................................... 41

Fig. 21 Jerarquía de la colección Set ................................................................................................................ 42

Fig. 22 Interfaz List ........................................................................................................................................... 43

Fig. 23 Jerarquía de la interfaz List .................................................................................................................. 44

Fig. 24 Interfaz Map y sus implmentaciones ................................................................................................... 48

Fig. 25 Collections sus interfaces e implementaciones ................................................................................... 48

iv
INTRODUCCIÓN

Las estructuras de datos son la parte principal de muchos algoritmos informáticos, ya que permiten a los
programadores manejar los datos de manera eficiente. Desempeña un papel importante en la mejora del
rendimiento de un software o un programa, ya que la función principal del software es almacenar y recuperar
los datos del usuario lo más rápido posible.

Estas estructuras proporcionan una forma eficiente de almacenar y organizar los datos en la computadora
para que se puedan usar de manera eficiente. En esta segunda parte de la Guía de Aprendizaje de Algoritmos
y Estructura de Datos I se pretende sentar las bases para ir entendiendo de manera paulatina los algoritmos
que permiten manipular las estructuras.

Primero se aborda la recursividad para poder entender luego los conceptos de búsqueda binaria y más
adelante los diferentes métodos de ordenamiento, profundizando mas adelante con las clases de Java que
ya trae de manera predefinida; profundizando más adelante con las colecciones. Se espera que esta Guía sea
de ayuda y orientación para los Estudiantes de la asignatura de Algoritmos y Estructura de Datos de la EAPIS
de la UNC.

Los Autores.

v
1 RECURSIVIDAD

Ante de desarrollar el tema hagamos la siguiente lectura para luego interactuar en el link que se le comparte.

Torres de Hanoi (https://www.geogebra.org/m/NqyWJVra)

El juego, en su forma más tradicional, consiste en tres varillas verticales. En una de las varillas se apila un
número indeterminado de discos (elaborados de madera) que determinará la complejidad de la solución, por
regla general se consideran ocho discos. Los discos se apilan sobre una varilla en tamaño decreciente. No hay
dos discos iguales, y todos ellos están apilados de mayor a menor radio en una de las varillas, quedando las
otras dos varillas vacantes. El juego consiste en pasar todos los discos de la varilla ocupada (es decir la que
posee la torre) a una de las otras varillas vacantes. Para realizar este objetivo, es necesario seguir tres simples
reglas:

✓ Sólo se puede mover un disco cada vez.

✓ Un disco de mayor tamaño no puede descansar sobre uno más pequeño que él mismo.
✓ Sólo puedes desplazar el disco que se encuentre arriba en cada varilla.

Fig. 1 Juego de Torres de Hanoi

¿** saberes previos?

✓ ¿Cómo se almacena un vector en la memoria RAM?

✓ ¿Puedo modificar el tamaño de un vector una vez creado?
✓ ¿Cómo puedo saber cuál es el tamaño de un vector? Es una propiedad o un método
 ✓ ¿Cómo determinamos las filas y columnas de una matriz?
✓ ¿Cuál es el código de los métodos principales para manipular una matriz?

¿Qué pasaría si?

• Nos piden implementar un programa que indique que pasos se debe de seguir para dar solución al
problema de las torres de hanoi. Para realizar este objetivo, es necesario seguir tres simples reglas:

✓ Sólo se puede mover un disco cada vez.

✓ Un disco de mayor tamaño no puede descansar sobre uno más pequeño que él mismo.
✓ Sólo puedes desplazar el disco que se encuentre arriba en cada varilla

Logro

Al finalizar la sesión, el estudiante elabora una “clase Java con métodos estáticos llamada Recursividad” que
implemente métodos que solucionen los ejercicios propuestos, creando para cada uno de ellos su “clase de
prueba”, presentado con orden y claridad en sus soluciones.

Desarrollo del tema

1.1.1 Atributos y métodos estáticos

Al hablar de atributos estáticos cada objeto de la clase comparte la misma copia de los atributos de ámbito
de clase y por lo tanto cada objeto, por lo tanto, tendrá los mismos valores de atributos de ámbito de clase

Los métodos se pueden definir como ámbito de clase, la invocación de un método de ámbito de clase no se
aplica a ninguna instancia específica de la clase – más bien, se puede pensar de los métodos de ámbito de
clase cómo aplicarlas a la misma clase. Puede invocar un método de ámbito de clase incluso si no existe
ninguna instancia de la clase – esto es ideal para los métodos de constructores. La figura siguiente muestra
la representación UML de una clase con atributos y métodos estáticos.
Recursividad

Fig. 2 Representación UML de atributos y métodos estáticos

P á g i n a 7 | 49
 Algoritmos y Estructura de Datos I

1.1.2 Recursividad. Métodos recursivos

Se dice que un método es recursivo cuando se define en función de si mismo. No todos los métodos pueden
llamarse a sí mismos, deben estar diseñados especialmente para que sean recursivos, de otro modo podrían
conducir a bucles infinitos, o a que el programa termine inadecuadamente. Algunos ejemplos de métodos
recursivos.

Ejemplo 1: Crear un método recursivo para calcular el factorial de un número entero.

El factorial se simboliza como n!, se lee como "n factorial", y la definición es: n! = n * (n-1) * (n-2) * ... * 1

5! = 5 * 4! 5! = 5*4*3!

5! = 5*4*3*2! 5! = 5*4*3*2*1!

5! = 5*4*3*2*1*0! 5! = 5*4*3*2*1*1

Además, se conoce que el factorial de cero y uno es uno.

✓ Condición base: si n=0, entonces factorial(n)=1

✓ Expresión recursiva: sino factorial(n) = n * factorial(n-1)

A partir de este análisis se plantea la solución

private static int fac(int n) {

if (n==0) {
return 1;
} else {
return n * fac(n-1);
}
}

Ejemplo 2: Crear un método recursivo para calcular el máximo común divisor de dos números usando el
algoritmo de Euclides.

El algoritmo consiste en dividir sucesivamente ambos números hasta que el divisor sea cero. El MCD será el
último divisor, para el ejemplo mostrado: 17. Para hacer estas divisiones sucesivas es de mucha ayuda una
tabla como se observa en la figura.
Recursividad

P á g i n a 8 | 49
 Fig. 3 Método de Euclides para encontrar el MCD de dos números

Al observar la tabla nos damos cuenta que se divide ambos números, si el residuo es diferente de cero se
repite el mismo procedimiento. Veamos:

- 2363%2057=306 (residuo) - 2057%306 =221

- 306 %221=85 - 221%85=51

- 85%51=34 - 51%34=17

- 34%17=0

Lo único que nos interesa calcular es el residuo hasta que este llegue a ser cero (0). En este punto diremos
que el MCD es 17.

A partir de este análisis se plantea la solución

private static int mcd(int a, int b) {

if (a%b==0) {
return b;
} else {
return mcd(b,a%b);
}
}

Ejemplo 3: Crear un método recursivo que muestre los n primeros términos de la serie de Fibonacci 0, 1, 1,
2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …

Para generar los valores de la serie partiendo de los iniciales 0, 1 se puede usar la siguiente expresión fb =
fb1 + fb2. Entonces se va a ir generando cada elemento de la serie de la forma siguiente:

1=0+1 2=1+1
Recursividad

3=1+2 5=2+3

8=3+5 13 = 5 + 8

P á g i n a 9 | 49
 Algoritmos y Estructura de Datos I

21 = 8 + 13 34 = 13 + 21

A partir del análisis anterior se plantea la solución siguiente de manera recursiva. Es importante observar en
las soluciones la condición base y la condición recursiva.

private static int fib(int n) {

if (n==1 || n==2) {
return 1;
} else {
return fib(n-2)+fib(n-1);
}
}

Al ejecutar un programa con métodos recursivos hace mayor uso de memoria, aunque la solución es sencilla;
observe la figura que muestra cómo se ejecuta para el caso del método de factorial.

Fig. 4 Llamada recursiva para el ejemplo del método factorial ()

La recursividad se debe usar cuando sea realmente necesaria, es decir, cuando no exista una solución
iterativa simple.
Recursividad

En los ejemplos solucionados previamente se debe de tener en cuenta que, para evitar un bucle infinito, un
algoritmo recursivo tendrá:

P á g i n a 10 | 49
✓ Condición base o fin de recursión. La función devuelve un valor simple sin utilizar la recursión.
✓ Expresión recursiva o caso general. Se hacen llamadas recursivas que se van aproximando a la condición
base.

Fig. 5 Método recursivo

Las funciones recursivos o recurrentes se pueden clasificar de dos formas distintas de acuerdo a algunos
autores: Recursividad directa y Recursividad indirecta; otros autores hacen referencia a una recursividad
múltiple y recursividad anidada.

Recursividad directa. Se presenta cuando la función se manda llamar a sí mismo dentro de su propio cuerpo
de instrucciones. Ver la figura siguiente.

public int metodo(int n){

…
n = metodo(n-1);
}

private static int mcd(int a, int b) {

if (a%b==0) {
return b;
} else {
return mcd(b,a%b);
}
}

Fig. 6 Ejemplo de método recursivo directo

Recursividad indirecta. Se manifiesta cundo una función llama a otra y dentro de la segunda se manda llamar
Recursividad

a la primera. O cuando existe la llamada a la función de forma encadenada y al terminar la última función
llamada, transfiere el control a la anterior, hasta llegar a la función que inicio la serie de llamadas.

P á g i n a 11 | 49
 Algoritmos y Estructura de Datos I

public int funcion1(int n){

…
n = funcion2(n-1);
}

public int funcion2(int n){

…
n = funcion1(n-1);
}

int par(int nump){

if(nump==0)
return(1);
return(impar(nump-1));
}

int impar(int numi){

if(numi==0)
return(0);
return( par(numi-1))
}

Fig. 7 Ejemplo de método recursivo indirecto

Recursividad múltiple. Se da cuando hay más de una llamada a sí misma dentro del cuerpo de la función.

int fib(int n){

if(n<=1)
return(1);
return(fib(n-1) + fib(n-2));
}

Recursividad anidada. En algunos de los argumentos de la llamada recursiva hay una nueva llamada a sí
misma.

int ack( int n, int m ) {

/* ejemplo: Ackerman */
if(n==0)
return(m+1);
else if(m==0)
return(ack(n-1,1));
return(ack(n-1, ack(n,m-1)));
}
Recursividad

P á g i n a 12 | 49
1.2 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN

Revise el contenido del capítulo y responda a las siguientes preguntas

✓ ¿Qué es recursividad?
✓ ¿Qué ventajas tiene la recursividad?
✓ ¿Cuál es la desventaja de la recursividad?
✓ ¿Qué debemos tener en cuenta para resolver un problema de forma recursiva?
✓ ¿Puedo resolver cualquier problema de manera recursiva?

Recuerde dar solución a las Torres de Hanoi

Ejercicios de aplicación

✓ Convierta un número de base 10 a base 2

✓ Encuentre el máximo elemento de un arreglo
✓ Escriba un algoritmo recursivo que permita mostrar los caracteres de una frase de manera invertida
✓ Dados dos números enteros a y b crear una función recursiva que calcule ab.
✓ Escribir una función recursiva que encuentre la suma de los n primeros números.

Recursividad

P á g i n a 13 | 49
 Algoritmos y Estructura de Datos I

2 CLASE VECTOR

Los arreglos son de bastante utilidad en nuestra vida diaria. Hemos visto como crear arreglos y
manipularlos, pero cada vez que tenemos que solucionar un problema repetimos el código. ¿Cómo se
puede mejorar los programas?

¿** saberes previos?

✓ ¿Cómo defino un arreglo un arreglo?

✓ ¿Cuál es el código que utilizo para leer un arreglo?
✓ ¿Cuál es el código para mostrar un arreglo?
✓ ¿Cómo hemos mejorado este código?
✓ ¿Qué es la recursividad?
✓ ¿Cuándo debemos utilizar la recursividad?
✓ ¿Qué debemos tener en cuenta para resolver un problema de forma recursiva?

¿Qué pasaría sí?

Tengo que resolver los siguientes problemas:

✓ Calcular la media armónica de un conjunto de datos

✓ Calcular la media geométrica de un conjunto de datos
✓ Diga si un elemento se encuentra en un array.

Cómo lo resolvería de tal manera que no tenga que repetir el código de leer y mostrar los elementos del
vector en cada programa y se preocupe en solucionar el problema

Logro

Al término de la sesión, el estudiante elabora una “clase Java”, sobre las tareas básicas de un vector y de una
matriz, que permitan resolver de mejor manera los problemas propuestos al final de la sesión; presentando
la solución de los mismos utilizando los conceptos de la POO.
Clase Vector

Desarrollo del tema

P á g i n a 14 | 49
2.1 DEFINICIÓN DE UNA CLASE

2.1.1 Clase Vector

Por ahora diremos que una clase describe las características y el comportamiento de un conjunto de objetos
similares en un contexto determinado. Para el ejemplo que a desarrollar se crea la clase “Vector” que más
adelante se utilizará para crear un tipo de dato.

Se crea la Vector

public class Vector {

Fig. 8 Define la clase Vector

2.1.1.1 Atributos de una clase (Características)

Se añade un atributo que internamente trabaja el

vector en sí

public class Vector {

int[] v;
}

Fig. 9 Agrega atributos a la clase Vector

2.1.1.2 Métodos de una clase (comportamiento)

Se añade comportamiento a la
public class Vector {
clase, y se crea el método genrarV()
int[] v;

public void generarV() {

for (int i = 0; i < v.length; i++) {
v[i] = (int) (Math.random()*20);
}
}
}

Fig. 10 Método generar Vector para la clase Vector

Clase Vector

P á g i n a 15 | 49
 Algoritmos y Estructura de Datos I

public class Vector {

int[] v;
...
public void mostrarV() {
System.out.println();
for (int i = 0; i < v.length; i++) {
System.out.print(v[i]+ "\t");
}
System.out.println();
}
}

Fig. 11 Método mostrar para la clase Vector

2.1.1.3 Métodos especiales

Pero hay un método especial que permite crear un objeto de la clase, este método se llama método
constructor, el mismo que tiene las siguientes características:

✓ Tiene el mismo nombre que la clase

✓ No devuelve ningún tipo de dato, ni siquiera void
✓ Puede tener parámetros como cualquier método
✓ Puede estar sobrecargado
✓ Y se encarga de inicializar los atributos de una clase
Se pueden agregar métodos y constructores

public class Vector {

int[] v;

//método constructor
public Vector(int n) {
v = new int[n];
}
...
}

Fig. 12 Método constructor para la clase Vector

Antes de seguir avanzando vamos a realizar una prueba de la clase Vector; para ello es necesario crear una
clase de prueba en donde se tiene que definir una variable (objeto)

public class PruebaVector {

En el main() de la clase de prueba se public static void main(String[] args) {
crea un vector de la clase “Vector” que Scanner sc = new Scanner(System.in);
intrnamente llama al atributo “v” que es System.out.print("numero de elementos: ");
un vector int n = sc.nextInt();
Clase Vector

Vector a = new Vector(n);

a.generarV();
a.mostrarV();
}
}

P á g i n a 16 | 49
 Fig. 13 Prueba de la clase Vector

Reflexione sobre el trabajo realizado hasta el momento y responda a las siguientes interrogantes sobre la
clase vector creada:

Fig. 14 Clase Vector

✓ ¿Qué mejoras podemos hacer respecto de la clase Vector propuesta?

✓ ¿Como podríamos mostrar los elementos del vector
✓ ¿Como podría considerar el caso en el que no se desea llenar todos los elementos del vector?
Considere los siguientes casos:
o Insertar un elemento
o Eliminar un elemento
o Buscar un elemento
✓ ¿Qué otros métodos, considera se puede agregar?
✓ ¿Cuál de los métodos indicados podría programar?
✓ ¿Podría generar un nuevo vector a partir de dos vectores iniciales? ¿Qué alternativas hay?

Investigue la clase Vector que viene implementada en Java

2.1.1.4 Clase Matriz

De manera similar a la clase Vector implemente su clase Matriz, definiendo atributos y métodos que permitan
realizar las diferentes tareas propias para manipular matrices. Observe la clase Matriz de la figura siguiente
y tome como base para realizar su programa, además indique ¿qué cambios haría o qué otros métodos
implementaría?
Clase Vector

P á g i n a 17 | 49
 Algoritmos y Estructura de Datos I

Fig. 15 Clase Matriz

Investigue cómo funciona el método clone con los arreglos

2.2 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN

Revise el contenido del capítulo y responda a las siguientes preguntas

✓ ¿En qué se diferencia la clase Vector que acabamos de crear con un vector tradicional?
✓ ¿Qué métodos han sido necesarios para implementar la clase Vector?
✓ ¿Qué atributos tiene la clase Vector creada?
✓ ¿Qué hace el constructor?
✓ ¿podría declarar e inicializar el atributo de Vector en una sola línea?

Ejercicios de aplicación
Clase Vector

Haciendo uso de la clase Vector cree un programa que:

✓ Calcule la media aritmética de un conjunto de datos

P á g i n a 18 | 49
 ✓ Calcule el promedio ponderado de un conjunto de datos
✓ Calcule la varianza y desviación estándar de un conjunto de datos
✓ Ordene un conjunto de datos de mayor a menor mostrando paso a paso su solución.

Haciendo uso de la clase Matriz cree un programa que:

Encuentre la suma de dos matrices

Encuentre el producto de dos matrices

Resuelva el siguiente problema: La empresa Alpine quiere producir acero. Serán necesarias, entre otras
materias primas, mineral hierro y carbón duro. Existen tres proveedores diferentes que ofrecen estas
materias primas. ¿Cuál es el proveedor que ofrece mayor beneficio? Las siguientes tablas muestran las
demandas (en toneladas) y los costes por tonelada de materia prima para cada proveedor:

Mineral Hierro Carbón duro

1ra Semana 9t 8t
2da Semana 5t 7t
3ra Semana 6t 4t

Ruhr AG Iron Ore AG Hard Coal and co.

Mineral Hierro 540 630 530

Carbón duro 420 410 440

Clase Vector

P á g i n a 19 | 49
 Algoritmos y Estructura de Datos I

3 MÉTODOS DE ORDENAMIENTO

Haga clic en la figura y observe la animación en Internet

Recordemos

✓ ¿Qué es ordenar?
✓ ¿Qué criterios podemos utilizar para ordenar?
✓ ¿Podrías ordenar estos números 8, 6, 3, 7, 1?
✓ ¿En la vida diaria en que momentos ordenamos?
✓ En nuestro qué hacer diario, ¿utilizamos el ordenamiento?
✓ Describa los pasos en que se ordenan los números de la figura (haga clic en la figura)
Métodos de ordenamiento

✓ ¿Qué métodos de ordenamiento conoce?

P á g i n a 20 | 49
 ¿Qué pasaría sí?

Le piden escribir el algoritmo de ordenamiento de dos métodos distintos. ¿Podría hacerlo?

Logro

Al término de la sesión, el estudiante explica en un informe los métodos de ordenamiento Selección,

Inserción, Quicksort, Shell y Merge, consultando información en libros y escribiendo para cada método de
ordenamiento sus respectivos ejemplos en java.

Desarrollo del tema

3.1 ORDENAMIENTO

Dada una secuencia de n elementos, {a0, a1, a2, ..., an-1} el problema de la ordenación se define como la
obtención de una permutación {a’0, a’1, a’2, …, a’n-1} de dicha secuencia que cumpla que a’0 ≤ a’1 ≤ a’2, ≤ a’n-1
donde ≤ es una relación de orden definida entre los elementos de la misma.

Existen diversas estrategias para resolver este problema, pero, del mismo modo, los tiempos que invierten
para ello pueden llegar a ser muy diferentes entre sí, dependiendo en todos los casos del número de
elementos a ordenar y, en algunos, además, de su disposición en la secuencia inicial.

3.1.1 Ordenamiento Burbuja (Bubble sort)

Consiste en ciclar repetidamente a través del vector, comparando elementos adyacentes de dos en dos. Si
un elemento es mayor que el que está en la siguiente posición se intercambian. Ejemplo

Ordenar:
Métodos de ordenamiento

89 63 47 50 49 3
PASO: 1
63 89 47 50 49 3
63 47 89 50 49 3
63 47 50 89 49 3
63 47 50 49 89 3
63 47 50 49 3 89
PASO: 2
47 63 50 49 3 89
47 50 63 49 3 89
47 50 49 63 3 89

P á g i n a 21 | 49
 Algoritmos y Estructura de Datos I

47 50 49 3 63 89
PASO: 3
47 50 49 3 63 89
47 49 50 3 63 89
47 49 3 50 63 89
PASO: 4
47 49 3 50 63 89
47 3 49 50 63 89
PASO: 5
3 47 49 50 63 89

3.1.2 Ordenamiento por inserción

Este algoritmo se usa frecuentemente cuando n es pequeño, el método consiste en insertar un elemento en
el vector en una parte ya ordenada de este vector y comenzar de nuevo con los elementos restantes. Por ser
utilizado generalmente por los jugadores de cartas también se le conoce con el nombre de método de la
baraja. Pasos:

✓ Se toma el primer elemento que por sí mismo está trivialmente ordenado.

✓ Luego se toma el segundo elemento y se compara con el que se tiene: si es mayor, lo colocamos a la
derecha, y si es menor a la izquierda.
✓ Después se toma el tercer elemento y se compara con las que se tiene en la mano, desplazándola
hasta que quede en su posición final.
✓ Se continúa haciendo esto, insertando cada carta en la posición que le corresponde, hasta que todas
estén en orden.
✓ Para simular esto en un programa se necesita tener en cuenta que no se puede desplazar los
elementos, así como así o se perderá un elemento.
✓ Lo que se hace es guardar una copia del elemento actual (que sería como la carta que se toma) y
desplazar todos los elementos mayores hacia la derecha. Luego se copia el elemento guardado en la
posición del último elemento que se desplazó.

Ejemplo:
Métodos de ordenamiento

Clasificar la siguiente lista de números en orden ascendente:

4 3 5 2 1

✓ temp toma el valor del segundo elemento, 3. La primera carta es el 4. Ahora comparamos: 3 es menor
que 4. Luego desplazamos el 4 una posición a la derecha y después copiamos el 3 en su lugar.

4 4 5 2 1
3 4 5 2 1

P á g i n a 22 | 49
✓ El siguiente elemento es 5. Comparamos con 4. Es mayor que 4, así que no ocurren intercambios.

3 4 5 2 1

✓ Continuamos con el 2. Es menor que cinco: desplazamos el 5 una posición a la derecha:

3 4 5 5 1

✓ Comparamos con 4: es menor, así que desplazamos el 4 una posición a la derecha:

3 4 4 5 1

✓ Comparamos con 3. Desplazamos el 3 una posición a la derecha:

3 3 4 5 1

✓ Finalmente copiamos el 2 en su posición final:

2 3 4 5 1

✓ El último elemento a ordenar es el 1. Cinco es menor que 1, así que lo desplazamos una posición a la
derecha:

2 3 4 5 5

✓ Continuando con el procedimiento la lista va quedando así:

2 3 4 4 5
2 3 3 4 5
2 2 3 4 5
1 2 3 4 5

3.1.3 Ordenamiento por selección

El algoritmo de selección sigue los siguientes pasos:

✓ Se busca el elemento más pequeño de la lista.

Métodos de ordenamiento

✓ Luego se lo intercambia con el elemento ubicado en la primera posición de la lista.

✓ Se busca el segundo elemento más pequeño de la lista.
✓ Se intercambia con el elemento que ocupa la segunda posición en la lista.
✓ Repetir este proceso hasta que se tenga ordenada toda la lista.

Ejemplo. Ordenar la siguiente lista de números en orden ascendente:

320 96 16 90 120 80 200 64

P á g i n a 23 | 49
 Algoritmos y Estructura de Datos I

✓ El método comienza buscando el número más pequeño y se lo intercambia con el elemento en la

primera posición. La nueva lista será:

16 96 320 90 120 80 200 64

✓ Luego se busca el siguiente número más pequeño: 64 y lo intercambiamos:

16 64 320 90 120 80 200 96

✓ Se siguen realizando las iteraciones encontrando:

16 64 80 90 120 320 200 96

16 64 80 90 120 320 200 96
16 64 80 90 96 320 200 120
16 64 80 90 96 120 200 320
16 64 80 90 96 120 200 320

3.1.4 Quick sort

Esta es probablemente la técnica más rápida conocida, desarrollada por Hoare en 1960. El método se basa
en la estrategia típica “divide y vencerás” (divide and conquer), ya que es más rápido y fácil de ordenar dos
listas pequeñas que una lista grande.

Se denomina método de ordenación rápido porque, en general, puede ordenar una lista de datos mucho más
rápidamente que cualquiera de los métodos de ordenación ya estudiados.

3.1.5 Shell

El método de ordenamiento se denomina Shell en honor de su inventor Donald Shell y mejora el

ordenamiento por inserción al romper la lista original en varias sub listas más pequeñas, cada una de las
cuales se ordena mediante un ordenamiento por inserción. En lugar de dividir la lista en sub listas de ítems
contiguos, el ordenamiento de Shell usa un incremento i, para crear una sub lista eligiendo todos los ítems
que están separados por i ítems.
Métodos de ordenamiento

Generaliza el ordenamiento por inserción que: es eficiente si la entrada está "casi ordenada" y es ineficiente,
en general, porque mueve los valores sólo una posición cada vez.

3.1.6 Ordenación por mezcla o merge sort (combinación)

El algoritmo de ordenación por mezcla o merge sort es un algoritmo recursivo consistente en dividir el array
por la mitad, dando lugar a dos subarrays del mismo tamaño, luego se ordena cada subarray por separado
mediante una llamada recursiva; a continuación, se fusiona ambas partes (ya ordenadas) respetando la

P á g i n a 24 | 49
relación de orden. El caso base de este algoritmo se plantea para un array con un solo elemento. En tal caso
no se hace nada, ya que dicho array, por definición, ya está ordenado.

3.2 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN

Revise el contenido del capítulo y responda a las siguientes preguntas

✓ ¿Qué es ordenar?
✓ ¿Qué tipos de ordenamiento conoce?
✓ ¿Cuál sería la utilidad de ordenar la información?
✓ ¿Qué métodos de ordenamiento hemos estudiado?
✓ Describa algunos de los métodos estudiados
✓ Escriba su algoritmo
✓ ¿Conoce algún otro método de ordenamiento?

Ejercicios de aplicación

✓ Escoja cualquiera de los métodos de ordenamiento estudiado y determine cuántas comparaciones

se hace
✓ Al programa anterior modifíquelo de tal forma que muestre los diferentes cambios paso a paso que
se hacen en un determinado método.
✓ Vuelva a escribir los diferentes métodos de ordenamiento utilizando otros tipos de datos (utilice
String o un arreglo de una clase cualquiera)
✓ Desarrollar un programa que implemente el siguiente menú, para administrar los datos de nuestros
amigos (correlativo, nombre, celular y edad):
o [1] Listar amigos
Métodos de ordenamiento

o [2] Registrar nuevo

o [3] Modificar datos
o [4] Eliminar amigo
o [5] Ordenar por nombre/secuencia
o [6] Buscar por nombre/celular
o [7] Salir

P á g i n a 25 | 49
 Algoritmos y Estructura de Datos I

4 MÉTODOS DE BÚSQUEDA

Observe el siguiente video.

https://youtu.be/0q5ygrtFtrA

¿Qué sabemos?

✓ ¿Qué es buscar?
✓ ¿Cómo buscamos?
✓ ¿Siempre buscamos de la misma manera?
✓ ¿Qué tipos de búsqueda conocemos?
✓ ¿Considera importante el orden al realizar una búsqueda? ¿Por qué?
✓ ¿Qué tan a menudo realizamos una búsqueda? ¿Son importantes?
Métodos de búsqueda

¿Qué pasaría sí…

… nos piden verificar la existencia de un valor cualquiera “x” en un vector de 10 000 elementos, cómo
realizaríamos una búsqueda de tal forma que se minimice el número de comparaciones?

Logro

P á g i n a 26 | 49
Al término de la sesión, el estudiante resuelve los problemas propuestos, empleando los conceptos
estudiados en el presente tema verificando su planteamiento como los resultados obtenidos.

Desarrollo del tema

4.1 BÚSQUEDA

La recuperación de información, es una de las aplicaciones más importantes de las computadoras y la

búsqueda (searching) de información está relacionada con las tablas para consulta.

El problema de búsqueda cae naturalmente dentro de uno de los dos casos:

✓ Si existen muchos registros, puede ser necesario almacenarlos en dispositivos como discos, externos
a la memoria de la computadora. Búsqueda externa.
✓ En el otro caso los registros que se buscan se almacenan por completo dentro de la memoria de la
computadora. Búsqueda interna

En la práctica, la búsqueda se refiere a la operación de encontrar la posición de un elemento entre un

conjunto de elementos dados: lista, tabla, fichero, ejemplos típicos de búsqueda son: localizar nombres y
apellidos de un alumno, localizar números de teléfono, etc. Existen diferentes algoritmos de búsqueda. El
algoritmo elegido depende de la forma en que se encuentren organizados los datos. Los métodos más usuales
de búsqueda son:

✓ Búsqueda secuencial o lineal

✓ Búsqueda binaria
✓ Búsqueda por transformación de claves (hash)

4.1.1 Búsqueda secuencial - Análisis

Tiene el inconveniente del consumo excesivo de tiempo en la localización del elemento designado.

✓ Si no se encuentra, se verifican los “n” elementos.

Métodos de búsqueda

✓ Si se encuentra en la lista podrá ser el primero, el último o alguno comprendido entre ambos.

𝑛+1
El número medio de comprobaciones es de .
2

INICIO
Desde i=1 hasta n hacer
si v[i]=x entonces

P á g i n a 27 | 49
 Algoritmos y Estructura de Datos I

escribir “Elemento encontrado”

fin_si
Fin_desde
FIN

4.1.2 Búsqueda binaria

La búsqueda binaria utiliza el método de divide y vencerás para localizar el valor deseado. Esta requiere que
los datos que se buscan estén clasificados en un determinado orden, con este método se examina primero
el elemento central de la lista; si éste es el elemento buscado entonces la búsqueda ha terminado, en caso
contrario, se determina si el elemento buscado está en la primera o la segunda mitad de la lista y a
continuación se repite este proceso, utilizando el elemento central de esta sublista.

Leer x
Inicio  1
Fin  n
Centro  entero((inicio + fin)/2)
Mientras inicio <= fin y v[centro] <> x
Si x < v[centro]
fin  central-1
sino
inicio  centro + 1
Fin_si
Centro  entero((inicio + fin)/2)
Fin_mientras
Si x = v[centro]
entonces escribir “valor encontrado en” centro
sino escribir “valor no encontrado”
Fin Si

Análisis

La búsqueda binaria es un método eficiente siempre que el vector esté ordenado, en la práctica esto suele
suceder, pero no siempre, por lo que es necesario una ordenación previa del vector; para obtener el número
de comparaciones que realiza el algoritmo consideremos un vector de 7 elementos, el número (N+1=8) se
debe dividir en tres mitades antes de que se alcance 1; es decir se necesita 3 comparaciones. El medio
matemático de expresar estos números es: 3 = 𝑙𝑜𝑔2 8

4.1.3 Algoritmos de búsqueda recursiva

Métodos de búsqueda

Al igual que en el caso de los algoritmos iterativos, consideraremos dos casos respecto al estado de los
elementos sobre los cuales se desea hacer la búsqueda: que no tengan orden alguno y que estén ordenados
respecto a algún criterio. Cuando se hace una búsqueda sobre un arreglo del cual no se tiene más información
que su tamaño, la idea general, como vimos anteriormente, es recorrer todo el arreglo y detenerse cuando
se encuentre el número x que se está buscando o cuando se haya verificado que x no iguala a algún elemento
del arreglo.

P á g i n a 28 | 49
función buscar (entero a[], entero n, entero x)
inicio
si n = 0 entonces
regresar 0
sino
si a[n] = x entonces
regresar n
si no
regresar buscar (a, n-1, x)
fin si
fin si
fin

Considere ahora el caso cuando los elementos del arreglo a están ordenados, digamos en forma ascendente.
Al igual que en el caso iterativo, se podría aprovechar esta propiedad e incluir una condición de control con
el fin de detener las llamadas recursivas justo cuando el algoritmo descubra que no tiene caso buscar a x en
cierta región del arreglo.

función buscar (entero a[], entero n, entero x)

inicio
si n = 0 ∨ a[n] < x entonces
regresar 0
sino
si a[n] = x entonces
regresar n
si no
regresar buscar (a, n-1, x)
fin si
fin si
fin

4.1.4 Búsqueda mediante transformación de claves (hashing)

La búsqueda binaria proporciona un medio para reducir el tiempo requerido para buscar en una lista. Este
método, sin embargo, exige que los datos estén ordenados. Existen otros métodos que pueden aumentar la
velocidad de búsqueda en el que los datos no necesitan estar ordenados, este método se conoce como
transformación de claves (clave dirección) o hashing.

El método de transformación de claves consiste en convertir la clave dada (numérica o alfanumérica) en una
dirección (índice) dentro del array como se observa en la figura siguiente; la correspondencia entre las claves
y la dirección en el array se establece por una función de conversión (función o hash).
Métodos de búsqueda

P á g i n a 29 | 49
 Algoritmos y Estructura de Datos I

Fig. 16 Representación de una Funciones hash

Otro concepto importante en el hashing son las colisiones, estas suceden cuando la función hash devuelve el
mismo valor, vea la siguiente figura.
Métodos de búsqueda

Fig. 17 Ejemplo de colisiones

Para realizar la transformación de claves existen varios métodos.

P á g i n a 30 | 49
4.1.4.1 Truncamiento

Ignora parte de la clave y se utiliza la parte restante directamente como índice. Si las claves son enteros de
ocho dígitos y la tabla de transformación tiene mil posiciones, entonces el primero, segundo y quinto dígitos
desde la derecha pueden formar la función de conversión. Por ejemplo, 72588495 se convierte en 895.

4.1.4.2 Plegamiento

La técnica del plegamiento consiste en la partición de la clave en diferentes partes y la combinación de las
partes en un modo conveniente (a menudo utilizando suma o multiplicación) para obtener el índice.

Un entero de ocho dígitos se puede dividir en grupos de tres, tres y dos dígitos, los grupos se suman y se
truncan si es necesario para que estén en el rango adecuado de índices. Por consiguiente, si la clave es:
62538194 y el número de direcciones es 100, la función de conversión será:

✓ 625 + 381 + 94 = 1100

Que se truncará a 100 y que será la dirección deseada.

4.1.4.3 Aritmética modular

Convierte la clave a un entero, divide por el tamaño del rango del índice y toma el resto como resultado.

✓ h(x) = x mod m

Donde m es el tamaño del array con índices de 0 a m – 1. Los valores de la función —direcciones— (el resto)
irán de 0 a m – 1, ligeramente menor que el tamaño del array.

4.1.4.4 Mitad del cuadrado

Este método consiste en calcular el cuadrado de la clave x. La función de conversión se define como

✓ h(x) = c
Métodos de búsqueda

Donde c se obtiene eliminando dígitos a ambos extremos de x2. Se deben utilizar las mismas posiciones de x2
para todas las claves.

Una empresa tiene ochenta empleados y cada uno de ellos tiene un número de identificación de cuatro
dígitos y el conjunto de direcciones de memoria varía en el rango de 0 a 100. Calcular las direcciones de:
4205, 7148 y 3350

P á g i n a 31 | 49
 Algoritmos y Estructura de Datos I

X 4205 7148 3350

X2 17 682 025 51 093 904 11 122 250

Si elegimos, por ejemplo, el cuarto y quinto dígito significativo, quedaría

h(x)= 82 93 22

4.1.5 Colisiones

La función de conversión h(x) no siempre proporciona valores distintos, puede que se obtenga la misma
dirección (colisión) y se debe encontrar métodos para su solución. Los ejemplos vistos anteriormente de las
claves DNI correspondientes al archivo de empleados, en el caso de cien posibles direcciones. Si se considera
el método del módulo en el caso de las claves, y se considera el número 101

123445678 123445880 proporcionarían las direcciones:

h (123445678) = 123445678 mod 101 = 44

h (123445880) = 123445880 mod 101 = 44

4.2 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN

Revise el contenido del capítulo y responda a las siguientes preguntas

✓ ¿Qué tipos de búsqueda conocemos?

✓ ¿En qué consiste la búsqueda binaria?
✓ ¿Qué entendemos por tablas hash?
✓ ¿Qué métodos de transformación de claves tenemos?
✓ ¿Describa en qué consiste cada método?
✓ ¿Qué es una colisión?
✓ ¿Cómo podemos resolver una colisión?
Métodos de búsqueda

Ejercicios de aplicación

✓ Realizar una búsqueda binaria de un listado de n nombres y apellidos ingresados por consola.
✓ Realizar una búsqueda recursiva de un listado de países que hemos ingresado a través del teclado
✓ Buscar un curso dentro de un arreglo de cursos.

P á g i n a 32 | 49
✓ Los números empleados —campo clave— de una empresa constan de cuatro dígitos y las direcciones
reales son 100. Se desea calcular las direcciones correspondientes por el método de plegamiento de
los empleados. (4205, 8148 y 3355).
✓ Un vector T tiene cien posiciones, 0..100. Supongamos que las claves de búsqueda de los elementos
de la tabla son enteros positivos (por ejemplo, número del DNI). Utilizando aritmética modular
encontrar su posición en el arreglo.

Métodos de búsqueda

P á g i n a 33 | 49
 Algoritmos y Estructura de Datos I

5 CLASE ARRAYS

Hasta ahora hemos estudiado una serie de métodos que han servido
para realizar búsquedas, ordenamiento y llenado de vectores, entre
otras funciones; para arreglos con tipos primitivos de datos y arreglos
de objetos. ¿Pero será necesario que reinventemos la rueda?

¿Qué recuerda?

✓ ¿Cómo define una clase Vector que permita almacenar números decimales?
✓ ¿Qué métodos agregaría?
✓ ¿Y si su clase vector ahora fuera de Personas qué cambios tendría que hacer?
✓ ¿Podría pensar en una clase Vector genérica?
✓ ¿Qué métodos de ordenamiento y búsqueda recuerda?

¿Cómo lo resuelvo?

En ellas clases anteriores se vio cómo implementar nuestros propios algoritmos de búsqueda y
ordenamiento, los cuales son de gran interés como investigadores y estudiantes afines a las ciencias
computacionales. Pero ahora nuestro enfoque está en usar las herramientas integradas que proporciona la
API de Java. Entonces, ¿cómo hago estas tareas sin necesidad de programarlas?

Logro

Al término de la sesión, el estudiante elabora un programa java, usando los métodos de la clase Arrays,
verificando su funcionamiento así como el uso de sus métodos sobrecargados.

Desarrollo del tema

5.1 CLASE ARRAYS

Clase Arrays

La clase Arrays es una clase de utilidad introducida en el JDK 1.2 que contiene métodos static para manipular
arreglos. Permite también ver los arreglos como listas.

P á g i n a 34 | 49
Esta clase proporciona métodos de alto nivel para realizar búsquedas, ordenamiento y llenado, entre otras
funciones; para arreglos con tipos primitivos de datos y arreglos de objetos. La clase Arrays pertenece al
paquete java.util. Los principales métodos de la clase Arrays se muestra en la tabla siguiente.

Retorno Método Descripción

Busca en el arreglo del primer parámetro, el
static int binarySearch(int[] a, int key) elemento int del segundo parámetro mediante
búsqueda binaria y retorna su índice.
Busca en el arreglo del primer parámetro, en el
binarySearch(int[] a, int rango especificado en el segundo y tercer
static int
fromIndex, int toIndex, int key) parámetro, el elemento int del cuarto parámetro
mediante búsqueda binaria y retorna su índice.
copyOf(int[] original, int
static int[] Copia el arreglo int en la longitud especificada.
newLength)
static boolean equals(int[] a, int[] a2) Retorna verdadero si los arreglos int son iguales.
Llena el arreglo int con el valor del segundo
static void fill(int[] a, int val)
parámetro.
fill(int[] a, fromIndex, int Llena el arreglo int en el rango del segundo y tercer
static void
toIndex, int val) parámetro con el valor del cuarto parámetro.
Ordena el arreglo int en orden ascendente
static void sort(int[] a)
numéricamente.

Para prevenir errores

✓ Al comparar el contenido de arreglos, use siempre Arrays.equals(arreglo1, arreglo2), que compara el

contenido de dos arreglos, en vez de arreglo1.equals(arreglo2), que compara si arreglo1 y arreglo2 hacen
referencia al mismo objeto arreglo.
✓ Pasar un arreglo desordenado al método binarySearch es un error lógico; el valor devuelto es indefinido.

Ejemplo: Crear una clase de prueba con un método main y en ella generar un vector de n elementos de
manera aleatoria y utilizando los métodos de Arrays de tal forma que llene, muestre, ordene, realice una
búsqueda binaria, copie arreglos y finalmente determine si estos son iguales. El siguiente código muestra una
propuesta para el enunciado propuesto.
Clase Arrays

package arrays;

import java.lang.reflect.Array;

P á g i n a 35 | 49
 Algoritmos y Estructura de Datos I

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Número de elementos del vector: ");
int n = sc.nextInt();

int[] v = new int[n];

mostrarV(v);
//llenamos el vector con 9s
Arrays.fill(v, 9);
mostrarV(v);
generarV(v);
mostrarV(v);
//ordena el vector a través de la clase Arrays
Arrays.sort(v);
System.out.println("Vector ordenado\n"+ Arrays.toString(v));
System.out.print("Elemento a buscar: ");
int x = sc.nextInt();
int resultado = Arrays.binarySearch(v, x);
if (resultado >= 0) {
System.out.println("Encontrado en: " + (resultado + 1));
} else {
System.out.println("Elemento NO encontrado");
}

//crea una copia del vector v en el vector w

int[] w = Arrays.copyOf(v, v.length);
System.out.println("vector w \n" + Arrays.toString(w));
//v[2] = 22;
System.out.println("vector v \n" + Arrays.toString(v));
System.out.println("vector w \n" + Arrays.toString(w));

System.out.println(v.equals(w));

Arrays.fill(w,2,5,3);
System.out.println("vector w \n" + Arrays.toString(w));
}

private static void generarV(int[] v) {

Random r = new Random();
Clase Arrays

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

v[i] = r.nextInt(50);
}
}

P á g i n a 36 | 49
 private static void mostrarV(int[] v) {
System.out.println();
for (int i : v) {
System.out.print(i + "\t");
}
System.out.println();
}
}

5.2 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN

Recordemos algo de lo que se ha aprendido

✓ ¿Qué métodos le han resultado útiles de la clase Arrays?

✓ ¿Qué tipo de clase es Arrays?
✓ ¿Qué ventajas y desventajas encuentra respecto de la clase Vector creada por Ud.?
✓ ¿Existe algún método que pueda utilizarlo con un arreglo bidimensional (Matriz)?

Ejercicios de aplicación

✓ Cree un programa de tal manera que al buscar un elemento muestre la posición correcta y si no se
ha encontrado que muestre un mensaje indicando que no existe.
✓ Podría Resolver ejercicios similares con cualquier otro tipo de dato, que tal un String.

Clase Arrays

P á g i n a 37 | 49
 Algoritmos y Estructura de Datos I

6 COLECCIONES - CONJUNTOS Y LISTAS

Java dispone de un conjunto de clases para agrupar objetos, denominadas colecciones. Cada clase organiza
los objetos de una forma particular, como un mapa, una lista, un conjunto..., y se implementa como un Tipo
Abstracto de Datos. Las colecciones son importantes para el desarrollo de programas profesionales dado que
facilitan considerablemente el diseño y construcción de aplicaciones basadas en estructuras de datos tales
como vectores, listas, conjuntos, mapas. La clase Vector procede de la versión original de Java. En Java 2 se
han potenciado las colecciones con nuevas clases e interfaces, todas ellas en el paquete java.util.

Recordemos respondiendo a estas preguntas

• Dada la siguiente instrucción:

– int[] v = new int[10];

• ¿Qué sucede si mostramos v?

• Si cada entero necesita 4 bytes para ser almacenado y del arreglo “v” hemos guardado solo 3 enteros,
¿cuánto de memoria consumimos?

• ¿Cómo se guarda un arreglo en la memoria RAM?

• ¿Cómo puedo almacenar varios elementos de un mismo tipo?

• ¿Cómo podemos crear una colección de objetos?

• ¿Qué ventajas y desventajas tiene la propuesta planteada?

¿Qué pasaría sí …
Colecciones - conjuntos y listas

… me piden crear una lista de fracciones que se inserten una a una pero una vez que se muestren están ya
ordenadas?

Logro

Al término de la sesión, el estudiante elabora un programa que solucione el ejercicio propuesto a través de
un menú de opciones, manteniendo su código ordenado y fácil de mantener.

P á g i n a 38 | 49
 Desarrollo del tema

6.1 INTRODUCCIÓN

Hay veces que los arreglos no son adecuados o suficientes por características del problema que hay que
resolver. Puede ser que se necesite almacenar elementos, pero que no se sepa cuántos elementos se van a
tener, en este caso, un arreglo con número fijo de elementos no es adecuado. Para solucionar estos
problemas surgen las típicas agrupaciones de elementos, pilas, colas, tablas hash, conjuntos, etc.

6.2 COLLECTION

Para estos tipos de agrupaciones, Java proporciona las llamadas Collections (Colecciones) que proporcionan
varias abstracciones para conjuntos (Set), listas (List), tablas hash (Map), etc. La jerarquía
Collection.Collection es una interfaz no una clase; la diferencia entre clase e interfaz es que una interfaz es
una clase que no tiene implementados sus métodos. Su representación UML y el código se muestran en la
figura siguiente.

public interfaz Collection{

boolean add(Object o);
boolean addAll(Collection c);
void clear();
boolean contains(Object o);
boolean containsAll(Collection c);
boolean equals(Object o);
int hashCode();
boolean isEmpty();
Iterator iterator();
boolean remove(Object o);
boolean removeAll(Collection c);
boolean retainAll(Collection c);
int size();
Object[ ] toArray();
Object[ ] toArray(Object[ ] a);
} Colecciones - conjuntos y listas

Fig. 18 Interfaz Collection

Todas las colecciones se encuentran en el paquete java.util.*. java.util.Collection es la raíz de la jerarquía de

las colecciones. Existen especializaciones que permitan elementos duplicados o no, que permitan ordenar
los elementos o no, etc. Esta interfaz contiene la definición de todos los métodos genéricos que deben
implementar las colecciones.

Métodos de Operaciones Básicas:

P á g i n a 39 | 49
 Algoritmos y Estructura de Datos I

✓ int size(): Número de elementos que contiene.

✓ boolean isEmpty(): Si no contiene ningún elemento.
✓ boolean contains(Object elemento): Si contiene ese elemento.
✓ boolean add(Object elemento): Añadir un elemento.
✓ boolean remove(Object elemento): Borrar un elemento.
✓ Iterator iterator(): Devuelve una instancia de Iterator.

Métodos de operaciones masivas:

✓ boolean containsAll(Collection c): Si contiene todos esos elementos.

✓ boolean addAll(Collection c): Añade todos esos elementos.
✓ boolean removeAll(Collection c): Borra todos esos elementos.
✓ boolean retainAll(Collection c): Borra todos los elementos menos esos concretos.
✓ void clear(): Borra todos los elementos.

Métodos de Operaciones con Arreglos:

✓ Object[ ] toArray(): Devuelve un array con todos los elementos.

✓ Object[ ] toArray(Object a[ ]): Devuelve un array con todos los elementos. El tipo será el del array
enviado.

Las colecciones no permiten el uso de tipos primitivos; por lo que, si necesitamos trabajar con ellos habrá
que usar los Wrappers de tipos primitivos.

6.3 INTERFAZ ITERATOR

El interfaz Iterator representa un componente que permite iterar sobre los elementos de una colección.
Todas las colecciones ofrecen una implementación de Iterator por medio del método:
Colecciones - conjuntos y listas

✓ public Iterator iterator();

Sus métodos son:

✓ boolean hasNext(): Si tiene más elementos.

✓ Object next(): Devuelve el primer elemento y se queda apuntando al siguiente.
✓ boolean remove(): Elimina el primer elemento y se queda apuntando al siguiente.

P á g i n a 40 | 49
 Fig. 19 Interfaz Iterator

6.4 INTERFAZ SET

El interfaz Set hereda del interfaz Collection. Pero no añade la definición de ningún método nuevo, no
permite tener elementos duplicados. Para saber si un elemento está duplicado, hace uso del método:

✓ public boolean equals(Object elemento);

La siguiente figura muestra la interfaz Set heredando de la interfaz Collection.

Fig. 20 Interfaz Set

Colecciones - conjuntos y listas

Existen distintas implementaciones de esta interfaz.

HashSet (SDK 1.2.X.).

✓ Ofrece el acceso más rápido cuando dicho acceso es aleatorio.

✓ Su orden de iteración es impredecible.

LinkedHashSet (SDK 1.4.X.)

P á g i n a 41 | 49
 Algoritmos y Estructura de Datos I

✓ Su orden de iteración es el orden de inserción.

TreeSet (SDK 1.2.X.)

✓ Su orden de iteración depende de la implementación que los elementos hagan del interfaz
java.lang.Comparable.
o public int compareTo(Object elemento);

En la figura siguiente se puede observar la jerarquía de la colección Set

Fig. 21 Jerarquía de la colección Set

6.5 INTERFAZ LIST

Colecciones - conjuntos y listas

El interfaz List hereda del interfaz Collection, representan colecciones con elementos en secuencia, es decir,
con orden y permite tener duplicados; además es accesible mediante índice, de manera que se puede:

✓ Acceder a un elemento concreto de una posición.

✓ Insertar un elemento en una posición concreta.

La figura siguiente muestra a la interfaz List.

P á g i n a 42 | 49
 Fig. 22 Interfaz List

Métodos para acceso posicional

✓ Object get(int index): Devuelve el elemento de esa posición.

✓ Object set(int index, Object elemento): Reemplaza el elemento de esa posición con ese elemento.
✓ void add(int index, Object elemento): Inserta ese elemento en esa posición.
✓ Object remove(int index): Elimina el elemento de esa posición.
✓ boolean addAll(int index, Collection c): Inserta todos esos elementos en esa posición.

Métodos para Búsqueda

✓ int indexOf(Object elemento): Devuelve la posición de la primera ocurrencia de ese elemento.

✓ int lastIndexOf(Object elemento): Devuelve la posición de la última ocurrencia de ese elemento.

Subcolecciones Colecciones - conjuntos y listas

✓ List subList(int from, int to): Devuelve una lista con los elementos comprendidos entre ambas
posiciones.

Existen distintas implementaciones de esta interfaz.

ArrayList (SDK 1.2.X.)

Ofrece un tiempo de acceso óptimo cuando dicho acceso es aleatorio.

LinkedList (SDK 1.2.X.)

P á g i n a 43 | 49
 Algoritmos y Estructura de Datos I

Ofrece un tiempo de acceso óptimo cuando dicho acceso es para añadir o eliminar elementos del comienzo
y final de la lista (tipico para pilas).

Vector

Es como el ArrayList pero sincronizando lo que penaliza notablemente el rendimiento. La sincronización es

importante cuando más de un thread (hilo de ejecución) va a acceder a la colección.

Fig. 23 Jerarquía de la interfaz List

Colecciones - conjuntos y listas

6.6 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN

Revise el contenido del capítulo y responda a las siguientes preguntas

✓ ¿Qué es una Colección?

✓ ¿En qué se diferencia de un vector tradicional?
✓ ¿Cuál es la diferencia entre una clase y una interfaz?

P á g i n a 44 | 49
 ✓ ¿Qué clases implementan cada colección?
✓ ¿Cuál es la diferencia entre estas colecciones?
✓ ¿Qué método me permite añadir un elemento a una colección?
✓ ¿en qué se diferencia Iterator de ListIterator.
✓ ¿Qué utilizaría para insertar fracciones y al mostrarlas ya estén ordenadas?

Ejercicios de aplicación

✓ Crear un menú de opciones que permita gestionar la información de un contacto a través del
siguiente menú:

o [1] Listar contacto

o [2] Nuevo
o [3] Modificar
o [4] Buscar
o [5] Eliminar
o [6] Ordenar
o [7] salir

Se pide implementar un programa que gestione a través de un menú de opciones: estudiantes, cursos y la
matrícula de los mismos, teniendo en cuenta que un estudiante puede llevar varios cursos y un curso puede
ser llevado por varios estudiantes.

Colecciones - conjuntos y listas

P á g i n a 45 | 49
 Algoritmos y Estructura de Datos I

7 MAPAS

Las listas y conjuntos son geniales, pero a veces un mapa es la mejor colección (no una colección con una "C"
mayúscula; recuerde que los mapas son parte de las colecciones de Java, pero no implementan la interfaz
Collection)

Revise y responda a las siguientes preguntas

✓ ¿Cuál es la jerarquía de la interfaz Collections?

✓ ¿Qué tipos de datos usan las colecciones?
✓ Describa algunos métodos generales para las colecciones
✓ Liste métodos específicos para las listas
✓ ¿De qué manera se pueden ordenar los elementos de un conjunto y de una lista?

¿Qué pasaría sí…

… me piden registrar los datos una persona en donde el DNI no puede tener duplicados, a diferencia de los
nombres y apellidos que si puede tener duplicados?

Logro

Al término de la sesión, el estudiante resuelve los ejercicios propuestos sobre mapas, utilizando los métodos
adecuados, verificando el buen funcionamiento de cada uno de ellos.

Desarrollo del tema

7.1 INTERFAZ MAP

El interfaz Map no hereda del interfaz Collection, representa colecciones con parejas de elementos: clave y
valor, además no permite tener claves duplicadas, pero si valores duplicados. Para calcular la colocación de
un elemento se basa en el uso del método.

✓ public int hashCode();

Métodos para operaciones básicas

Mapas

P á g i n a 46 | 49
 ✓ Object put(Object key, Object value): Insertar una pareja.
✓ Object get(Object key): Accede al valor de una clave.
✓ Object remove(Object key): Eliminar una pareja.
✓ boolean containsKey(Object key): Comprueba la existencia de una clave.
✓ boolean containsValue(Object value): Comprueba la existencia de un valor.
✓ int size(): Número de parejas.
✓ boolean isEmpty(): Si no contiene ninguna pareja.

Métodos para Operaciones Masivas

✓ void putAll(Map t): Añade todas las parejas.

✓ void clear(): Elimina todas las parejas.

Métodos para Obtención de Colecciones

✓ public Set keySet(): Devuelve las claves en un Set.

✓ public Collection values(): Devuelve los valores en una Collection.

Existen distintas implementaciones de esta interfaz.

HashMap (SDK 1.2.X.). Ofrece un tiempo de acceso óptimo cuando dicho acceso es aleatorio.

Hashtable. Es la versión sincronizada de HashMap.

LinkedHashMap (SDK 1.4.X.). Su orden de iteración es el de inserción.

TreeMap. Su orden de iteración depende de la implementación que los elementos hagan del interfaz
java.lang.Comparable.

✓ public int compareTo(Object elemento);

La siguiente figura muestra la Interfaz Map y sus implementaciones.

Mapas

P á g i n a 47 | 49
 Algoritmos y Estructura de Datos I

Fig. 24 Interfaz Map y sus implmentaciones

La interfaz Map no hereda de Collections pero se la estudia dentro de las colecciones. De manera gráfica se
puede ver todas las implementaciones estudiadas hasta ahora, ver la figura siguiente.

Fig. 25 Collections sus interfaces e implementaciones

Mapas

En ocasiones un arreglo puede resultar más útil que una colección, todo depende de la necesidad que tenga
el programa, la tabla siguiente muestra una comparación entre los arreglos y colecciones.

P á g i n a 48 | 49
Tabla 1 Comparación entre arreglos y colecciones

Arreglo Colección

Tamaño estático. Tamaño dinámico.

Su tamaño se conoce mediante el atributo length. Su tamaño se conoce mediante el método size().

Puede almacenar tanto tipos primitivos como tipos Solo puede almacenar tipos complejos.
complejos.
Puede albergar elementos de distinto tipo.
Solo puede albergar elementos de un tipo.

7.2 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN

Revise el contenido del capítulo y responda a las siguientes preguntas

✓ En qué se diferencian los conjuntos, de las listas y mapas

✓ ¿Qué es Map?
✓ ¿Qué métodos tiene la interfaz Map?
✓ ¿Qué clases implementan la interfaz Map y cuáles son las características de cada una?

Ejercicios de aplicación

✓ Investigue dos problemas cualquiera donde pueda aplicar los conceptos aprendidos sobre mapas y
pueda dar solución usando mapas.

Mapas

P á g i n a 49 | 49