Diccionarios. Arrays y Árboles Binarios de Búsqueda.

1. Análisis y Diseño
de Software
Tema 2b.
Diccionarios.
Arrays y Árboles
Carlos A. Iglesias <cif@gsi.dit.upm.es>
Departamento de Ingeniería de Sistemas Telemáticos
http://moodle.dit.upm.es

2. Legenda
Teoría
Ejercicio práctico en el ordenador
Ampliación de conocimientos
Lectura / Vídeo / Podcast
Práctica libre / Experimentación
Explicación en pizarra
Diccionarios. Arrays y Árboles 2

3. Bibliografía
● Beginning Algorithms, Simon
Harris and James Ross, Wrox,
2005.
● Capítulos 1, 2, 9, 10, 11
http://proquest.safaribooksonline.com/book/software-engi
neering-and-development/algorithms/9780764596742
Diccionarios. Arrays y Árboles 3

4. Temario
● Estructura de datos: diccionarios
● Operaciones en diccionarios: interfaz
diccionario
● Implementación de diccionario
– Interfaz Comparable
– Array
– Array Ordenado
– Árbol binario para búsqueda
Diccionarios. Arrays y Árboles 4

5. Objetivos
● Aprender nuevas estructuras de datos,
ampliamente usadas para diccionarios
● Saber calcular, evaluar y razonar sobre la
complejidad de las operaciones de un
diccionario
● Practicar la programación de métodos
recursivos e iterativos para recorrer estas
estructuras
Diccionarios. Arrays y Árboles 5

6. El problema del diccionario
● Tenemos pares clave-elemento
– Ej. Palabra y definición de la palabra
● ¿Cómo insertar, borrar o buscar elementos
dada su clave? CLAVE ELEMENTO
1 Juan
insertar 3 Ana
4 Marcos
5 Pedro
buscar(1) 6 Fernando
1 Juan 7 Marga
Diccionarios. Arrays y Árboles 6

7. El problema diccionario
● Un diccionario es un 'mapping' entre dos
conjuntos de items, K y V, que debe
soportar:
– Inserción de un elemento v dada una clave k
– Búsqueda de un elemento dada su clave k
– Borrado de un elemento dada una clave k
K V
1 Juan
3 Ana
Pedro
5
Diccionarios. Arrays y Árboles 7

8. Requisitos diccionario
● Búsqueda rápida
● Inserción rápida
● Borrado rápido
Diccionarios. Arrays y Árboles 8

9. Interfaz Diccionario
Diccionarios. Arrays y Árboles 9

10. Ordenar objetos en Java
● En Java para ordenar, usamos al interfaz Comparable
● int c = a.compareTo(b)
● Orden: interface Comparable<T> {
int compareTo(T o);
– c<0→a<b }
– c == 0 → a == b
– c>0→a>b
● Al implementar Comparable, tenemos que cumplir:
– x.compareTo(y) == 0 ↔ x.equals(y)
– Transitividad. Si x.compareTo(y) > 0 && y.compareTo(z) > 0 →
x.compareTo(z) > 0
– Si x.compareTo(y) == 0 →
signo(x.compareTo(z)) == signo(y.compareTo(z)), para todo z
Diccionarios. Arrays y Árboles 10

11. Ejemplo
public class Persona implements Comparable {
private String nombre;
private String apellido;
private int edad;
public int compareTo(Persona otra) {
int c1 = apellido.compareTo(otra.apellido);
if (c1 != 0) { return c1;}
int c2 = nombre.compareTo(otra.nombre);
if (c2 !=0) {return c2;}
return otra.edad – edad;
}
}
Diccionarios. Arrays y Árboles 11

12. Problema
● Programar DiccionarioArray
– Implementa Diccionario
– Usa arrays
Diccionarios. Arrays y Árboles 12

13. Caso de estudio (1)
3 2 4 1
¿Cómo inserto, borro, y busco en este array?
Diccionarios. Arrays y Árboles 13

14. Caso de estudio (2)
1 2 3 4
¿Cómo inserto, borro, y busco en este array?
Diccionarios. Arrays y Árboles 14

15. Adivina un número entre 0 y
50 ...
¿Qué
preguntaríamos?
Diccionarios. Arrays y Árboles 15

16. Búsqueda binaria –
Arrays.binarySearch()
● Si sabemos que está ordenado,
– Dividimos el array por su elemento medio.
– Comparamos con el elemento del centro. Si
coincide, terminamos. Si el elemento es menor,
debe estar en el subarray de la izda, y si es mayor
en el de la derecha. Seguimos haciendo esto hasta
encontrarlo
• Ej. [1,2,3,4,5,6,7,8,9] y busco el 3
• [1,2,3,4]-5-[6,7,8,9] como 3 es menor que 5
• [1]-2-[3 ,4] como 3 es menor que 2 → []-3-[4] →
Encontrado
Diccionarios. Arrays y Árboles 16

17. Complejidad Búsqueda lineal
● Buscar – search
– Recorremos → O(n)
● Insertar - put
– Añadimos al final, sin detectar duplicados → O(1)
● Recuperar - get
– Buscamos el elemento → O(n)
● Borrar - remove
– Buscamos y lo borramos → O(n)
Diccionarios. Arrays y Árboles 17

18. Complejidad
Búsqueda binaria
● Buscar - search
– O(logn)
● Insertar - put
– Busco + reordeno hasta el final → O(n)
● Recuperar - get
– Busco → O(logn)
● Borrar - remove
– Busco + reordeno tras borrar → O(n)
– Si sólo marco como borrado: Busco + marco → O(logn)
Diccionarios. Arrays y Árboles 18

19. Complejidad
T(n)
Algoritmo search put get remove
Búsqueda lineal O(n) O(1) O(n) O(n)
Búsqueda binaria iterativa O(logn) O(n) O(logn) O(n)
Búsqueda binaria recursiva O(logn) O(n) O(logn) O(n)
E(n)
Algoritmo search put get remove
Búsqueda lineal O(1) O(1) O(1) O(1)
Búsqueda binaria iterativa O(1) O(1) O(1) O(1)
Búsqueda binaria recursiva O(logn) O(logn) O(logn) O(logn)
Diccionarios. Arrays y Árboles 19

20. Ahora, a programar...
Diccionarios. Arrays y Árboles 20

21. Clases vistas
● Diccionario.java
● TestDiccionario.java
● BancoPruebasDiccionarioOrdenado.java
● DiccionarioArray.java
● DiccionarioArrayOrdenado.java
Diccionarios. Arrays y Árboles 21

22. Medimos tiempos...
Diccionarios. Arrays y Árboles 22

23. ¿Cómo podría mejorar
búsqueda binaria?
● ¿Qué molesta?
– → REORDENAR al insertar o borrar
● “Ordeno de forma perezosa” (lazy sorting)
– Sólo cuando me hace falta
● Alternativas:
– Inserción ordenada + búsqueda binaria
– Inserción no ordenada + búsqueda lineal
– Inserción + ordenación perezosa + búsq. Binaria
●¿Cuándo cojo cada una?
Diccionarios. Arrays y Árboles 23

24. Ordenación perezosa
● Insertar al final y marcar que no está
ordenado data[pos++] = nuevoDato;
ordenado = false;
● Ordenamos antes de buscar con búsqueda
binaria
if !ordenado {
Arrays.sort(data);
ordenado = true;
}
return busqueda(datos, dato);
Diccionarios. Arrays y Árboles 24

25. Árboles binarios
● Vamos a ver cómo evitar 'reordenar' con
O(n)
● Los árboles binarios nos facilitan esto
Diccionarios. Arrays y Árboles 25

26. ¿Qué son los árboles binarios
(binary trees)?
●“Árboles”-> estructura Tree
– con nodos
– Cada nodo tiene un padre
● “Binarios”
– Cada padre tiene 2 hijos
Diccionarios. Arrays y Árboles 26

27. Árboles binarios
● La altura de un nodo es el número de
enlaces desde ese nodo hasta el nodo más
profundo
● La altura de un árbol es la altura del nodo
raíz
Diccionarios. Arrays y Árboles 27

28. Árbol binario lleno y completo
● Un árbol binario lleno es aquel en que
cada nodo tiene 0 ó 2 hijos (no 1)
● Un árbol binario completo es un árbol
binario completamente lleno, con la posible
excepción del último nivel
Diccionarios. Arrays y Árboles 28

29. Árbol binario completo
● Un árbol binario completo proporciona la
mejor relación entre número de nodos y la
altura
● La altura h de un árbol binario completo de
N nodos es h = O(log n) ya que
n=1+2+ 4+...+2 h−1 +2 h =2 h+1−1
Diccionarios. Arrays y Árboles 29

30. Árboles binarios de búsqueda
(Binary search trees)
● “Árboles binarios” en que además
– La rama izquierda de un nodo sólo tiene
valores menores que dicho nodo
– La rama derecha de un nodo sólo tiene
valores mayores que dicho nodo
– No hay duplicados
Diccionarios. Arrays y Árboles 30

31. Inserción
Diccionarios. Arrays y Árboles 31

32. Ej. Inserción
Diccionarios. Arrays y Árboles 32

33. Ejemplo
Diccionarios. Arrays y Árboles 33

34. Ejercicio
● Crear un árbol binario con los siguientes
números (insertar en este orden):
● 11, 6, 8, 19, 4, 10, 5, 17, 43, 49, 31
Diccionarios. Arrays y Árboles 34

35. Complejidad T(n)
● En árboles completos, lo peor sería que
tengamos que dar tantos saltos como la
altura del árbol → O(log n)
● PERO si el árbol no es completo, y es
degenerado, p.ej. Si los datos son
ordenados: (1 (2 (3 ( 4 (5)) → O(n)
1
2
3
4
5
Diccionarios. Arrays y Árboles 36

36. Borrado
● Casos
– Nodo sin hijos → lo borramos
– Nodo con 1 hijo → lo borramos y lo
reemplazamos por el hijo
– Nodo con 2 hijos →buscamos el mayor hijo
izado o el menor hijo derecho y reemplazamos
por el que queremos borrar
Diccionarios. Arrays y Árboles 37

37. Borrado sin hijos
Borrar 74
Diccionarios. Arrays y Árboles 38

38. Borrado nodo con 1 hijo
Borrar 70
Diccionarios. Arrays y Árboles 39

39. Borrado con 2 hijos
Borrar 59
Diccionarios. Arrays y Árboles 40

40. Ej. Borrado con 2 hijos
Borrar I
Diccionarios. Arrays y Árboles 41

41. Borrado perezoso
● En vez de borrar físicamente, marcamos
para borrado
– Más simple
– Podemos hacer los borrados físicos 'de golpe'
(y en batch)
– Pero, necesitaremos más memoria para los
nodos marcados como borrados, y se tardará
más en otras operaciones
Diccionarios. Arrays y Árboles 42

42. Complejidad
● Buscar - search
– Si es completo y balanceado, O(h) → O(logn)
– Si degenera, O(n)
● Insertar - put
– Buscar + insertar en ese nodo → O(logn)
● Recuperar – get
– Buscar → O(logn)
● Borrar - delete
– Buscar nodo + buscar reemplazo + insertar reemplazo en
nodo original → O(logn)+O(logn)+1 → O(logn)
Diccionarios. Arrays y Árboles 43

43. Complejidad
T(n)
Algoritmo search put get remove
Búsqueda lineal O(n) O(1) O(n) O(n)
Búsqueda binaria iterativa O(logn) O(n) O(logn) O(n)
Búsqueda binaria recursiva O(logn) O(n) O(logn) O(n)
Árbol binario de búsqueda O(logn) O(logn) O(logn) O(logn)
E(n)
Algoritmo search put get remove
Búsqueda lineal O(1) O(1) O(1) O(1)
Búsqueda binaria iterativa O(1) O(1) O(1) O(1)
Búsqueda binaria recursiva O(logn) O(logn) O(logn) O(logn)
Árbol binario de búsqueda O(n) O(n) O(n) O(n)
Diccionarios. Arrays y Árboles 44

44. Clases vistas
● DiccionarioArbol.java
●TestDiccionarioArbol.java
Diccionarios. Arrays y Árboles 45

45. Conclusiones - Búsqueda
“La búsqueda es una
herramienta básica que
cada programador
debería conocer para
utilizar en un gran número
de ocasiones”
Donald Knuth, “El Arte de
Programación de
Ordenadores”, Vol. 3, 1973.
Diccionarios. Arrays y Árboles 46

46. Resumen
● Tenemos diferentes algoritmos para
ordenar y buscar
● Las pruebas de prestaciones nos permiten
medirlos
– Es difícil (elementos externos como la máquina
o GC en Java)
● Hemos visto dos algoritmos de búsqueda:
lineal y binaria (para arrays ordenados)
Diccionarios. Arrays y Árboles 47