Guía de Aprendizaje Algoritmos y Estructura de Datos Parte 2
Guía de Aprendizaje Algoritmos y Estructura de Datos Parte 2
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
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.
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:
• 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:
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.
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
P á g i n a 7 | 49
Algoritmos y Estructura de Datos I
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.
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
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:
- 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.
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.
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.
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.
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.
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
Recursividad múltiple. Se da cuando hay más de una llamada a sí misma dentro del cuerpo de la función.
Recursividad anidada. En algunos de los argumentos de la llamada recursiva hay una nueva llamada a sí
misma.
P á g i n a 12 | 49
1.2 ACTIVIDADES DE REFLEXIÓN Y APLICACIÓN
✓ ¿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?
Ejercicios de aplicación
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?
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
P á g i n a 14 | 49
2.1 DEFINICIÓN DE UNA CLASE
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
Se añade comportamiento a la
public class Vector {
clase, y se crea el método genrarV()
int[] v;
P á g i n a 15 | 49
Algoritmos y Estructura de Datos I
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:
//método constructor
public Vector(int n) {
v = new int[n];
}
...
}
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)
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:
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
✓ ¿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
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.
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:
Clase Vector
P á g i n a 19 | 49
Algoritmos y Estructura de Datos I
3 MÉTODOS DE ORDENAMIENTO
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
P á g i n a 20 | 49
¿Qué pasaría sí?
Logro
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.
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
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:
Ejemplo:
Métodos de ordenamiento
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
3 4 5 5 1
3 4 4 5 1
3 3 4 5 1
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
2 3 4 4 5
2 3 3 4 5
2 2 3 4 5
1 2 3 4 5
P á g i n a 23 | 49
Algoritmos y Estructura de Datos I
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
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.
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.
✓ ¿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
P á g i n a 25 | 49
Algoritmos y Estructura de Datos I
4 MÉTODOS DE BÚSQUEDA
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
… 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.
4.1 BÚSQUEDA
✓ 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
Tiene el inconveniente del consumo excesivo de tiempo en la localización del elemento designado.
✓ 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
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
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.
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
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
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á:
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.
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
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
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.
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.
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;
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");
}
System.out.println(v.equals(w));
Arrays.fill(w,2,5,3);
System.out.println("vector w \n" + Arrays.toString(w));
}
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();
}
}
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
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.
• Si cada entero necesita 4 bytes para ser almacenado y del arreglo “v” hemos guardado solo 3 enteros,
¿cuánto de memoria consumimos?
¿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.
P á g i n a 39 | 49
Algoritmos y Estructura de Datos I
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.
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
P á g i n a 40 | 49
Fig. 19 Interfaz Iterator
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:
P á g i n a 41 | 49
Algoritmos y Estructura de Datos I
✓ 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);
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:
P á g i n a 42 | 49
Fig. 22 Interfaz List
✓ List subList(int from, int to): Devuelve una lista con los elementos comprendidos entre ambas
posiciones.
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
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ú:
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.
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)
… 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.
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.
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.
HashMap (SDK 1.2.X.). Ofrece un tiempo de acceso óptimo cuando dicho acceso es aleatorio.
TreeMap. Su orden de iteración depende de la implementación que los elementos hagan del interfaz
java.lang.Comparable.
P á g i n a 47 | 49
Algoritmos y Estructura de Datos I
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.
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
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.
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