Tema 2 diccionarios_grupo_23

Análisis y Diseño de Software

Departamento de Ingeniería de Sistemas Telemáticoshttp://moodle.dit.upm.es

Tema 2b.Diccionarios. Arrays y Árboles

Carlos A. Iglesias <[email protected]>

Diccionarios. Arrays y Árboles 2

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

Legenda


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


Temario

● Estructura de datos: diccionarios

● Operaciones en diccionarios: interfaz diccionario

● Implementación de diccionario– Interfaz Comparable– Array– Array Ordenado– Árbol binario para búsqueda


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


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?

Juan1

Ana3

Pedro5

Fernando6

Marcos4

CLAVE ELEMENTO

insertar

buscar(1)

Marga7Juan1


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

3

5

Juan

Ana

Pedro

1

V


Requisitos diccionario

● Búsqueda rápida

● Inserción rápida

● Borrado rápido


Interfaz Diccionario


Ordenar objetos en Java● En Java para ordenar, usamos al interfaz Comparable

● int c = a.compareTo(b)

● Orden:– 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

interface Comparable<T> { int compareTo(T o);}


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;

}}


Problema

● Programar DiccionarioArray– Implementa Diccionario– Usa arrays


Caso de estudio (1)

3 2 4 1

¿Cómo inserto, borro, y busco en este array?


Caso de estudio (2)

1 2 3 4

¿Cómo inserto, borro, y busco en este array?


Adivina un número entre 0 y 50 ...

¿Quépreguntaríamos?


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


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)


ComplejidadBú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)


Complejidad

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)


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)

T(n)

E(n)


Ahora, a programar...


Clases vistas

● Diccionario.java

● TestDiccionario.java

● BancoPruebasDiccionarioOrdenado.java

● DiccionarioArray.java

● DiccionarioArrayOrdenado.java


Medimos tiempos...


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


Ordenación perezosa

● Insertar al final y marcar que no está ordenado

● Ordenamos antes de buscar con búsqueda binaria

data[pos++] = nuevoDato; ordenado = false;

if !ordenado { Arrays.sort(data); ordenado = true;}return busqueda(datos, dato);


Árboles binarios

● Vamos a ver cómo evitar 'reordenar' con O(n)

● Los árboles binarios nos facilitan esto


¿Qué son los árboles binarios (binary trees)?

●“Árboles”-> estructura Tree– con nodos– Cada nodo tiene un padre

● “Binarios”– Cada padre tiene 2 hijos


Á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


Á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


Á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+...+2h−1+2h=2h+1−1


Á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


Inserción


Ej. Inserción


Ejemplo


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


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)

12

34

5


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


Borrado sin hijos

Borrar 74


Borrado nodo con 1 hijo

Borrar 70


Borrado con 2 hijos

Borrar 59


Ej. Borrado con 2 hijos

Borrar I


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


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)


Complejidad


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)


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)

T(n)

E(n)


Clases vistas

● DiccionarioArbol.java●TestDiccionarioArbol.java


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

Conclusiones - Búsqueda


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)

Tema 2 diccionarios_grupo_23

Technology

Transcript of Tema 2 diccionarios_grupo_23