Tema 7. Tablas de Dispersión

Transcripción

1 Tema 7. Tablas de Dispersión 1. Introducción 2. Funciones de dispersión 3. Resolución de colisiones Exploración lineal Exploración cuadrática Encadenamiento 4. Análisis de costes 5. Implementaciones en Java EDA. Curso 2002/2003. Tema 7. N.Prieto p.1/58

2 Objetivos Motivar computacionalmente el estudio de las tablas Hash como estructura de almacenamiento por nombre, por ejemplo para su uso como tabla de símbolos de un compilador Estudio de la utilidad de una elección lógica de una función de dispersión para lograr una ocupación equilibrada de la tabla Estudio de las soluciones ante la colisión en la aplicación de la función de dispersión Exploración lineal Exploración cuadrática Encadenamiento Implementaciones y algoritmos sobre tablas Hash EDA. Curso 2002/2003. Tema 7. N.Prieto p.2/58

3 Bibliografía M.A. Weiss. Estructuras de Datos en Java. Ed. Addison Wesley, Capítulo 6, apartado 7 y capítulo 19. T.H. Cormen, C.E. Leiserson, R.L.Rivest. Introduction to Algorithms. MIT Press, Capítulo 12 R. Wiener, L.J. Pinson. Fundamental of OOP and Data Structures in Java. Cambridge University Press, Capítulo 16. EDA. Curso 2002/2003. Tema 7. N.Prieto p.3/58

4 Para qué se usa una Tabla Hash? Una tabla hash es una estructura de datos para representar conjuntos Permite representar diccionarios proporcionando costes medios constantes para las operaciones Las operaciones basadas en ordenación de elementos (buscarmin o listado en orden) no pueden implementarse de forma tan eficiente como en los ABB EDA. Curso 2002/2003. Tema 7. N.Prieto p.4/58

5 Qué es una tabla hash? Una tabla hash viene definida por un vector para almacenar los datos una función de dispersión Un método de resolución de colisiones El paquete estandar java.util proporciona la clase Hashtable, que es una implementación robusta y eficiente de las tablas de dispersión. EDA. Curso 2002/2003. Tema 7. N.Prieto p.5/58

6 La función de dispersión Una función hash convierte un elemento en un entero adecuado para indexar el vector de cubetas, h : U 0..B 1 La función hash debe distribuir los elementos uniformemente por toda la tabla La función hash debe de poder ser calculada de forma eficiente La función hash no es inyectiva, por lo que se producen colisiones EDA. Curso 2002/2003. Tema 7. N.Prieto p.6/58

7 Resolución de colisiones Exploración lineal Exploración cuadrática Encadenamiento separado EDA. Curso 2002/2003. Tema 7. N.Prieto p.7/58

8 Medida de la eficiencia de una tabla hash Factor de carga: relación entre el número de elementos almacenados y el tamaño de la tabla, f = N/B Número de pruebas: número de comparaciones necesario para determinar la presencia de un elemento en una tabla Número medio de pruebas: Valores más pequeños indican mayor eficiencia de la tabla EDA. Curso 2002/2003. Tema 7. N.Prieto p.8/58

9 Definición de la función de dispersión Sobre los números naturales Método de la División: h(k)= k mod B B es el tamaño de la tabla B debe ser un número primo no cercano a una potencia de 2 Método de la Multiplicación: h(k)= B(kA mod 1) 0<A<1 se suele tomar B como una potencia de 2 Sobre las cadenas de caracteres EDA. Curso 2002/2003. Tema 7. N.Prieto p.9/58

10 Funciones hash sobre cadenas Definición 1: hashmala int hash (String clave) { int valorhash=0; for (int i=0;i<clave.length;i++) valorhash+=clave.charat(i); return (valorhash%b); Problemas: No distribuye bien las claves si el tamaño de la tabla es grande Ejemplo: B=10007 y clave.length<8; 0<=hash(clave)<=1016 hash(abc)=hash(bca) EDA. Curso 2002/2003. Tema 7. N.Prieto p.10/58

11 Funciones hash (2) Definición 2: int hash (String clave) { int valorhash=clave.charat(0); for (int i=1;i<clave.length;i++) valorhash=(valorhash*256+clave.charat(i)) % B; return (valorhash); Problemas: Cálculo más costoso debido al cálculo de la operación mdulo dentro del bucle EDA. Curso 2002/2003. Tema 7. N.Prieto p.11/58

12 Funciones hash (3) Definición 3 int hash (String clave) { int valorhash=clave.charat(0); for (int i=1;i<clave.length;i++) valorhash=(valorhash*256+clave.charat(i)); return (valorhash%b); Problemas: Desbordamiento EDA. Curso 2002/2003. Tema 7. N.Prieto p.12/58

13 Funciones hash (4) Definición 4: static public int hashweiss(string clave, int tamanyotabla){ int valorhash = 0; for (int i= 0; i < clave.length() ; i++) valorhash = 37 * valorhash + clave.charat(i); valorhash %= tamanyotabla; if (valorhash < 0) valorhash += tamanyotabla; return valorhash; EDA. Curso 2002/2003. Tema 7. N.Prieto p.13/58

14 Funciones hash (5) Definición 5: Otros valores de la base int hash (String clave) { int valorhash=0; for (int i=0;i<clave.length;i++) valorhash=valorhash*4+clave.charat(i); return (valorhash % B); int hash (String clave) { int valorhash=0; for (int i=0;i<clave.length;i++) valorhash=valorhash*37+clave.charat(i); valorhash%=b; if (valorhash<0) valorhash+=b; return (valorhash); EDA. Curso 2002/2003. Tema 7. N.Prieto p.14/58

15 Comparación entre funciones hash (1) public class CollisionExperiment { private final int NUMBER_WORDS = ; String [] table; public void computecollisions () { int hashindex = 0; try {System.out.print ("Size\ Collisions"); for (int size=number_words;size<=10*number_words;size+=number_w table = new String[size]; BufferedReader diskinput=new BufferedReader (new InputStream new FileInputStream (new File("distinct. int collisions = 0; String line = diskinput.readline(); while (line!= null && line.length() > 0) { hashindex = Math.abs(line.hashCode()) % size; if (table[hashindex]= null) table[hashindex]=line; else collisions++; line = diskinput.readline(); System.out.println (size+"\t"+collisions); catch (Exception ex) {System.out.println(ex); EDA. Curso 2002/2003. Tema 7. N.Prieto p.15/58

16 Comparación entre funciones hash (2)... static public void main (String[] args) { CollisionExperiment app=new CollisionExperiment(); app.computecollisions(); EDA. Curso 2002/2003. Tema 7. N.Prieto p.16/58

17 Comparación entre funciones hash (3) EDA. Curso 2002/2003. Tema 7. N.Prieto p.17/58

18 Comparación entre funciones hash (4) EDA. Curso 2002/2003. Tema 7. N.Prieto p.18/58

19 Funciones Hash (distinct.txt pal.) hashcode hashmala hashweiss hash4 hash27 Numero de colisiones e e+06 Tamaˆ o de la tabla Comparación entre funciones hash (5) EDA. Curso 2002/2003. Tema 7. N.Prieto p.19/58

20 Comparación entre funciones hash (6) Size hashcode hashmala hashweiss hash4 hash EDA. Curso 2002/2003. Tema 7. N.Prieto p.20/58

21 La clase Hashtable de java.util Métodos constructores: public Hashtable() // construye una tabla hash vacia con una capacidad inicial 11 // y factor de carga de 0.75 public Hashtable(int initialcapacity) // construye una tabla hash vacia con la capacidad especificada // en el parámetro y factor de carga de 0.75 public Hashtable(int initialcapacity, float loadfactor) // construye una tabla hash vacia con la capacidad y factor de // carga especificados en los parámetros EDA. Curso 2002/2003. Tema 7. N.Prieto p.21/58

22 La clase Hashtable Métodos modificadores: public Object put(object key, Object value) // Añade el valor a la tabla con clave key public Object remove(object key) // elimina la clave y su correspondiente valor de la tabla // Si el n o de elementos almacenados excede B*factorCarga, // el tamaño de la tabla se incrementa dinámicamente en B // para asegurar que el factor de carga no se incrementa EDA. Curso 2002/2003. Tema 7. N.Prieto p.22/58

23 La clase Hashtable Métodos consultores: public boolean containskey(object key) // Comprueba si es una clave en esta tabla public boolean containsvalue(object value) // comprueba si el objeto está en la tabla public Object get(object key) // devuelve el valor asociado a la clave en la tabla public int size() // devuelve el número de entradas en la tabla EDA. Curso 2002/2003. Tema 7. N.Prieto p.23/58

24 Evaluación Diseño del experimento para evaluar la rapidez de acceso a la información utilizando una tabla hash: Usaremos un objeto de la clase Hashtable, que usa la función de dispersión hashcode de la clase String Almacenaremos en la tabla las palabras distintas Calcularemos el tiempo medio de acceso para buscar todas estas claves en la tabla EDA. Curso 2002/2003. Tema 7. N.Prieto p.24/58

25 Programa en Java (1) public void performtest() throws Exception { // para medir el tiempo long elapsedtime = 0L;long starttime, endtime; // formato DecimalFormat df = new DecimalFormat("0.##"); hash = new Hashtable(250000); // para lectura BufferedReader diskinput;string line; diskinput=new BufferedReader (new InputStreamReader ( new FileInputStream(new File ("distinct.txt")))); // Cada línea del fichero se inserta en la tabla line = diskinput.readline(); while (line!= null) { hash.put(line, line); line = diskinput.readline(); System.out.println ("Talla de la tabla hash= "+hash.size()); EDA. Curso 2002/2003. Tema 7. N.Prieto p.25/58

26 Programa en Java (2)... System.out.println ("Buscando las palabras sobre la tabla"); elapsedtime = 0; diskinput = new BufferedReader (new InputStreamReader ( new FileInputStream(new File ("distinct.txt")))); line = diskinput.readline(); while (line!= null) { starttime = System.currentTimeMillis(); if (hash.containskey(line)) count++; endtime = System.currentTimeMillis(); elapsedtime += endtime - starttime; line = diskinput.readline(); System.out.println ("Palabras revisadas por segundo="+ (int)(count*1000.0/elapsedtime) +" palabras/seg."); EDA. Curso 2002/2003. Tema 7. N.Prieto p.26/58

27 Resultados: Talla de la tabla hash= Buscando las palabras sobre la tabla Palabras revisadas por segundo= palabras/ EDA. Curso 2002/2003. Tema 7. N.Prieto p.27/58

28 Resolución de colisiones Sobre la tabla Exploración Lineal Exploración cuadrática Fuera de la tabla: listas de colisiones EDA. Curso 2002/2003. Tema 7. N.Prieto p.28/58

29 Exploración Lineal Incluye la búsqueda secuencial hasta encontrar una posición vacia si la posición inicial dada por la función hash está ocupada por otra palabra. Búsqueda circular. Para factores de carga altos las secuencias de encadenamiento son muy altas y el tiempo medio de acceso puede ser muy elevado. Ejemplo C={89,18,49,58,9, h(x)=x % B, B=10 EDA. Curso 2002/2003. Tema 7. N.Prieto p.29/58

30 Algoritmo de inserción 1. Calcular el valor del índice hash para la palabra a insertar 2. Si la posición en el vector está vacia, insertar la nueva palabra en esta posición 3. Si la posición en el vector está ocupada con una palabra diferente, incrementar secuencialmente el índice hasta encontrar la palabra o una posición vacia 4. Si la búsqueda efectuada en el paso anterior no tiene éxito, insertar la palabra en la posición vacia encontrada. EDA. Curso 2002/2003. Tema 7. N.Prieto p.30/58

31 Evaluación de la inserción El número de pruebas asociada con la inserción de una palabra utilizando este método es igual al número de posiciones del vector consultadas. Para factores de carga altos se forman cadenas de colisiones muy grandes y el número de pruebas necesarias para buscar una palabra incrementa significativamente EDA. Curso 2002/2003. Tema 7. N.Prieto p.31/58

32 Algoritmo de búsqueda 1. Calcular el valor del índice hash para la palabra a insertar 2. Si la posición en el vector está vacia, la palabra no está 3. Si la posición en el vector está ocupada con una palabra diferente, incrementar secuencialmente el índice hasta encontrar la palabra o una posición vacia 4. Si la búsqueda efectuada en el paso anterior termina porque se encuentra una posición vacia, la palabra no está EDA. Curso 2002/2003. Tema 7. N.Prieto p.32/58

33 Algoritmo de borrado Eliminación perezosa 1. Calcular el valor del índice hash para la palabra a insertar 2. Si la posición en el vector contiene la palabra a borrar se marca. 3. Si la posición en el vector está ocupada con una palabra diferente, incrementar secuencialmente el índice hasta encontrar la palabra o una posición vacia 4. Si la búsqueda efectuada en el paso anterior termina porque se encuentra la palabra, se marca como borrada EDA. Curso 2002/2003. Tema 7. N.Prieto p.33/58

34 Efecto del factor de carga public class LinearChainingApp { // Atributos int probes; boolean [] words = new boolean [1000]; // Holds virtual words Random rnd = new Random(); int count; public void generatetable (double loadfactor) { for (int i=0;i<1000;i++) words[i]=false; //vaciar tabla count = (int)(1000*loadfactor); probes = 0; for (int i=0;i<count;i++) { int hashindex=rnd.nextint(1000); while (words[hashindex]==true) { hashindex++;probes++; if (hashindex==1000) hashindex=0; words[hashindex]=true; probes++; EDA. Curso 2002/2003. Tema 7. N.Prieto p.34/58

35 Efecto del factor de carga static public void main (String[] args) { DecimalFormat df = new DecimalFormat("#.00"); LinearChainingApp app = new LinearChainingApp(); System.out.println("Factor de carga\tnumero medio de pruebas"); for (double lf = 0.1; lf <= 0.9; lf += 0.1) { app.generatetable(lf); System.out.println(df.format(lf)+"\t\t"+ df.format((double)app.probes/app.count)); for (double lf = 0.91; lf < 1.0; lf += 0.01) { app.generatetable(lf); System.out.println(df.format(lf)+"\t\t"+ df.format((double)app.probes/app.count)); EDA. Curso 2002/2003. Tema 7. N.Prieto p.35/58

36 Resultados Factor de carga Número medio de pruebas EDA. Curso 2002/2003. Tema 7. N.Prieto p.36/58

37 EDA. Curso 2002/2003. Tema 7. N.Prieto p.37/58 16 Evaluaciˆon de la exploracion lineal "reslinearch" u 1: Numero Medio de Pruebas Factor de Carga

38 Conclusiones Hasta factores de carga del orden del 70 % el comportamiento de la tabla es muy bueno (sobre 2 comparaciones) Para factores de carga del 80 % y superiores el comportamiento de la tabla se degrada rápidamente Un ABB balanceado con 1000 nodos requiere un número medio de comparaciones de 9, comparable a una tabla hash con factor de carga del 0.95 Una tabla hash con factor de carga del orden de 0.6 tiene un comportamiento que es cuatro veces más rápido que un ABB balanceado EDA. Curso 2002/2003. Tema 7. N.Prieto p.38/58

39 Exploración Cuadrática Su nombre se debe al uso de la función F (i) = i 2 en la eliminación de los conflictos Búsqueda circular: H, H + 1 2, H + 2 2, H + 3 2,..., H + i 2 Ejemplo C={89,18,49,58,9, h(x)=x % B, B=10 Los puntos siguientes de prueba distan de la posición original un número cuadrático de posiciones EDA. Curso 2002/2003. Tema 7. N.Prieto p.39/58

40 Implementación de la EC El tamaño de la tabla debe de ser un número primo y el factor de carga no debe de ser superior al 0.5 (Teorema 19.4) para asegurar que siempre insertaremos el nuevo elemento y para asegurar que ninguna celda será consultada dos veces durante un acceso Cálculo eficiente de las sucesivas posiciones de prueba (Teorema 19.5) H i = H i 1 + 2i 1(modB) (1) Expansión dinámica de la tabla para mantener el factor de carga: rehashing EDA. Curso 2002/2003. Tema 7. N.Prieto p.40/58

41 1000 EDA. Curso 2002/2003. Tema 7. N.Prieto p.41/58 Lineal Cuadratica Logaritmo del Numero medio de pruebas factor de carga Exploracion lineal vs cuadratica (Random) Lineal Cuadratica 30 Numero medio de pruebas factor de carga

42 Resultados de EL vs EC Sobre enteros y con función de hash la identidad # Factor de carga NMP-EL NMP-EC EDA. Curso 2002/2003. Tema 7. N.Prieto p.42/58

43 Resultados de EL vs EC Sobre Strings con la función hashcode # Factor de carga NMP-EL NMP-EC EDA. Curso 2002/2003. Tema 7. N.Prieto p.43/58

44 Efectos del rehasing 1000 Ahorro de memoria con Hashing Enlazado Expl. Lineal Expl. Cuadr Expl. Enlazada Expl. Lineal rehash Expl. Cuadr rehash Log. del numero medio de pruebas EDA. Curso 2002/2003. Tema 7. N.Prieto p.44/58

45 Hashing Enlazado Método alternativo de resolución de colisiones Definidos una función de dispersión y un cierto tamaño B para la tabla... Cada grupo de colisiones se almacenan en una lista explícita El número medio de pruebas en este tipo de tablas será del orden de la longitud media de las listas Para obtener NMP del orden de 2, es necesario que las listas tengan en promedio 2 elementos la elección de una buena función de dispersión es un aspecto crítico Un tamaño apropiado para la tabla es un número primo próximo a N/2 ó N/3 EDA. Curso 2002/2003. Tema 7. N.Prieto p.45/58

46 Hashing Enlazado 1000 Expl. Lineal vs Cuadratica vs Enlazada Expl. Lineal Expl. Cuadratica Expl. Enlazada Log. numero medio de pruebas EDA. Curso 2002/2003. Tema 7. N.Prieto p.46/58

47 Hashing Enlazado Eficiencia del Hashing Enlazado vs capacidad de la tabla FC=100% FC=63% FC=50% Numero medio de intentos EDA. Curso 2002/2003. Tema 7. N.Prieto p.47/58

48 Implementacion en Java EDA. Curso 2002/2003. Tema 7. N.Prieto p.48/58

49 La clase ExploracionTablaHash public abstract class ExploracionTablaHash { //Atributos protected EntradaHash tabla[]; // tabla es un array de EntradaHash private static final int CAPACIDAD_POR_DEFECTO = 11; // capacidad ini protected int tamanyoactual; // cuántos, de capacidad elementos, tie public ExploracionTablaHash(){... public final void vaciar(){... public boolean esvacia(){... public int tamanyo() {... public final static int hash(string clave){... protected abstract int buscarpos(hashable x); public final Hashable buscar(hashable x) throws ElementoNoEncontrado{... public final void eliminar (Hashable x) throws ElementoNoEncontrado{... public final void insertar (Hashable x){... EDA. Curso 2002/2003. Tema 7. N.Prieto p.49/58

50 La clase EntradaHash public class EntradaHash { private Hashable elemento; private boolean activo; // Elemento del Diccionario en la Tabla H // Estado del Elemento en la TH para elim public EntradaHash(Hashable elemento) { this.elemento = elemento; activo = true; // this (elelemento, true); public EntradaHash(Hashable elemento, boolean suestado){ this.elemento = elemento; activo = suestado; public Hashable elelemento(){ return this.elemento; public boolean estaactivo(){return this.activo; public void elemento(hashable esteelemento){this.elemento=esteelemento public void activo(boolean esteestado){this.activo = esteestado; EDA. Curso 2002/2003. Tema 7. N.Prieto p.50/58

51 La interfaz Hashable public interface Hashable{ // Devuelve el entero que codifica la clave del elemento sobre el que // se aplica. El valor de dicho entero está en el intervalo [0..capac int hash(); EDA. Curso 2002/2003. Tema 7. N.Prieto p.51/58

52 La constructora y vaciar public ExploracionTablaHash(){ tabla = new EntradaHash[CAPACIDAD_POR_DEFECTO]; //una vez asignada memoria a tabla, la inicializamos: todas sus compon // a null y tamanyoactual == 0 vaciar(); public final void vaciar(){ this.tamanyoactual = 0; for (int i = 0; i < tabla.length; i++) tabla[i] = null ; EDA. Curso 2002/2003. Tema 7. N.Prieto p.52/58

53 El método abstracto buscarpos // Al buscar/insertar/eliminar un elemento Hashable x, se aplica siempre // la función de localización hash que se acaba de definir. Ahora bien, p // resolver los conflictos que ésta pudiera ocasionar, el diseñador elige // un método de resolución, de exploración, que determina en QUÉ posición // la TablaHash se va a buscar/insertar/eliminar el elemento x. // Por tanto, el método que utiliza buscar/insertar/eliminar para buscar // efectiva de x en la tabla DEBE DEFINIRSE como ABSTRACTO en Exploración // e implementarse en una clase que la extienda, TablaExploracionX protected abstract int buscarpos(hashable x); EDA. Curso 2002/2003. Tema 7. N.Prieto p.53/58

54 El método buscar public final Hashable buscar(hashable x) throws ElementoNoEncontrado{ int posactual=buscarpos(x); if (tabla[posactual]==null tabla[posactual].estaactivo()==false) throw new ElementoNoEncontrado("buscar de Exploración Tabla Hash") return tabla[posactual].elelemento(); EDA. Curso 2002/2003. Tema 7. N.Prieto p.54/58

55 El método eliminar public final void eliminar (Hashable x) throws ElementoNoEncontrado{ int posactual=buscarpos(x); if (tabla[posactual]==null tabla[posactual].estaactivo()==false ) throw new ElementoNoEncontrado("eliminar de Exploración Tabla Hash" // OJO: eliminación perezosa tabla[posactual].activo(false); EDA. Curso 2002/2003. Tema 7. N.Prieto p.55/58

56 El método insertar public final void insertar (Hashable x){ int posactual = buscarpos(x); //Si la Entrada ya existe, se sobre-escribe. No se lanza Excepción algu this.tabla[posactual] = new EntradaHash(x,true); this.tamanyoactual++; // Si el factor de ocupación es >= 50%: REHASHING if (tamanyoactual >= tabla.length / 2){ EntradaHash tablaantigua [] = tabla; // Crear la nueva tabla con el doble de capacidad int nuevacapacidad = siguienteprimo( 2*tablaAntigua.length); this.tabla = new EntradaHash[nuevaCapacidad]; this.tamanyoactual = 0; //se redispersan sobre la tabla nueva todas las entradas activas for (int i=0; i<tablaantigua.length; i++) if (tablaantigua[i]!=null && tablaantigua[i].estaactivo()) insertar(tablaantigua[i].elelemento()); EDA. Curso 2002/2003. Tema 7. N.Prieto p.56/58

57 clase ExploracionTablaCuadratic //Implementación de la técnica de resolución de conflictos Exploración Cu public class ExploracionTablaCuadratica extends ExploracionTablaHash { protected final int buscarpos(hashable x){ int colision = 0; // Aplicación de la función hash definida para x, que en realidad // invoca a la de ExploracionTablaHash, que es la de Weiss int posactual = x.hash()%this.tabla.length; if (posactual < 0) posactual += this.tabla.length; // Búsqueda del lugar de inserción, que NO será posactual // si se produce una colisión. Estrategia de Exploración Cuadrática while ( tabla[posactual]!= null &&!tabla[posactual].elelemento().eq posactual += 2 * ++ colision - 1 ; if (posactual>=tabla.length ) posactual-=tabla.length; return posactual; EDA. Curso 2002/2003. Tema 7. N.Prieto p.57/58

58 La clase ExploracionTablaLineal //Implementación de la técnica de resolución de conflictos Exploración Li public class ExploracionTablaLineal extends ExploracionTablaHash { protected final int buscarpos(hashable x){ int colision = 0; // Aplicación de la función hash definida para x, que en realidad // invoca a la de ExploracionTablaHash, que es la de Weiss int posactual = x.hash() % this.tabla.length; if (posactual < 0) posactual += this.tabla.length; // Búsqueda del lugar de inserción, que NO será posactual // si se produce una colisión. Estrategia de Exploración Lineal while ( tabla[posactual]!= null &&!tabla[posactual].elelemento().eq posactual++; colision++; if ( posactual >= tabla.length ) posactual =0; return posactual; EDA. Curso 2002/2003. Tema 7. N.Prieto p.58/58