1 UMLV 1. Introduction 2. Hachage ouvert 3. Hachage fermé 4. Implémentation des fonctions Méthodes de hachage

2 UMLV Recherche dichotomique d i f 4 ? d i f df table fonction ELEMENT (x, table, d, f ) ; début si (d = f) alors si (x = table [d ]) alors retour (vrai) sinon retour (faux) sinon { i (d+f ) / 2 ; si (x > table [i]) alors retour (ELEMENT (x, table, i+1, f )) sinon retour (ELEMENT (x, table, d, i)) } fin Temps (ELEMENT sur table [1 … n]) = O (log n)

UMLV Recherche par interpolation table di f di f 4 ? df fonction ELEMENT (x, table, d, f ) ; début si ( d = f ) alors si (x = table [d ] alors retour (vrai) sinon retour (faux) sinon { i d + si (x > table [i] alors retour (ELEMENT (x, table, i+1, f )) sinon retour (ELEMENT (x, table, d, i)) } fin

4 Idée : Établir une relation entre un élément et ladresse à laquelle il est rangé en mémoire Théorème : Si les éléments de table [1 … n] et x sont choisis uniformément dans un intervalle [a,b], le temps moyen dexécution de la recherche par interpolation est O (log log n) UMLV

5 Type abstrait « dictionnaire » Ensembles avec les opérations principales contains (x, A) add (x, A) temps constant en moyenne remove ( x, A) Implémentation non adapté au classement. Table de hachage table dont les indices sont dans [0.. B-1] Fonction de hachage h : éléments [0.. B-1]non injective en général Résolution des collisions Hachage ouvert : avec listes, triées ou non. Hachage fermé : linéaire, quadratique, aléatoire, uniforme, double,... UMLV Hachage

6 UMLV Hachage ouvert Liens explicites Taille variable int h (char x [ ], int B) { int i ; sum = 0 ; for (i = 0 ; x [i] != \0; i ++) { sum = sum + x [i] ; } return (sum % B) ; }

7 UMLV int hash (char * s) { char * p ; unsigned h = 0, g ; for (p = s ; * p ; p++) { h = (h<< 4) + (* p) ; if (g = h & 0xf ) { h = h ^ (g >> 24) ; h = h ^ g ; } return (h % PRIME) ; } Voir Aho, Sethi, Ullman, Compilers, Addison-Wesley, 1986

8 UMLV #define B 127 typedef struct cell { ElementType e; struct cell * next; } Cell typedef Cell * List ; void clear (List d [ ], int size) { int i ; for (i = 0; i < size; i ++) { d [ i ] = null ; } int contains (ElementType x, List d [ ] ) { List p ; p d [ h(x) ] ; while (p != null) { if (compare(p->e,x) == 0) return 1 ; else p p->next ; } retour 0 ; }

9 UMLV void add ( ElementType x, List d [ ]) { addListHead ( x, d, h(x) ) ; } x h(x)h(x) void addListHead (ElementType x, List d [ ], int i) { List p ; if ( contains (x, d) == 0) { p = (List ) malloc (sizeof (Cell)) p->e = x ; p->next = d [ i ] ; d [ i ] = p; }

10 Hachage ouvert - initialisation (clear) : O (B) - ajout : temps constant (après test d appartenance) - appartenance - suppression si les événements "h (x) = i" sont équiprobables Création d'une table de n éléments : UMLV Temps des opérations

11 UMLV Hachage fermé table 0101 B-1 liens implicites : gain de place taille limitée ré-allocation en cas de débordement Re-hachage h 0 (x) = h (x), h 1 (x), … h i (x), … où h i (x) dépend généralement de x et de i Suppression d un élément distinction entre « vide » et « disponible » facteur de charge : n / B où n = nombre d éléments

12 UMLV Hachage linéaire Re-hachage : h i (x) = (h(x) + i) % B FORWARD disponible THEN vide FOR TO B-1= 6 EXEMPLE B = 7 h (x) = (c – a) % B où c première lettre de x add (BEGIN) add (FOR) add (FUNCTION) add (FORWARD) add (THEN) remove (FUNCTION) remove (BEGIN) add (TO) A H O V B I P W C J Q X D K R Y E L S Z F M T G N U

13 UMLV ã #define B 7 #define VIDE 0 #define DISPONIBLE 1 void clear (ElementType d [ ]) { int i ; for (i = 0, i < B, i ++) { d [ i] VIDE ; } int position (ElementType x, ElementType d [ ]) { /* calcule la seule position possible où ajouter x dans A */ int i ; i = 0 ; while ( ((i < B) && (compare(d [h i (x)], x) != 0) ) && ((d [h i (x)] != VIDE) && (d [h i (x)] != DISPONIBLE)) ) { i = i + 1 ; } return (h i (x)) ; }

14 UMLV int positionForContains (ElementType x, ElementType d [ ]) { int hi, dernier ; hi h (x) ; dernier (hi + B-1) % B ; while (( hi != dernier && (d [hi] {x, VIDE})) { hi (hi + 1) % B ; } return (hi) } int contains (ElementType x, ElementType d [ ]) { if (compare(d [positionForContains (x, d)], x) == 0) return 1 ; else return 0 ; } void remove (ElementType x élément, ElementType d [ ]) { int i ; i = positionForContains (x, d) ; if (compare(d [ i ], x) == 0) d [ i ] = DISPONIBLE ; }

15 UMLV int positionForAdd (ElementType x, ElementType d [ ]) { int hi, dernier; hi = h (x) ; dernier := (hi + B-1) % B ; while ((hi != dernier) && (d [hi] {x, VIDE, DISPONIBLE})) { hi (hi + 1) % B ; } return hi ; } void add (ElementType x, ElementType d [ ]) { int i ; i = positionForAdd (x, d) ; if (d [ i ] {VIDE, DISPONIBLE} ) { d [ i ] = x ; } else if (compare(d [ i ], x ) != 0) { error ( " table pleine " ) ; }

16 UMLV Hachage quadratique Re-hachage : h i (x) = (h (x) + i ²) % B int position (ElementType x, ElementType d [ ]) { int hi, inc; hi = h (x) ; inc = 1 ; while ((inc < B) && (A [hi] {x, VIDE, ? }) { hi = (hi + inc) % B ; inc = inc + 2 ; } return hi ; } seule la moitié de la table est examinée par re-hachage utiliser la suite : h (x), h (x) + 1, h (x) - 1, h (x) + 4, h (x) - 4, … avec B premier.

17 UMLV Hachage double Re-hachage : h i (x) = (h(x) + i g (x)) % B - B premier et 1 g (x) B ou B premier avec chacun des g (x) pour examen de toute la table par re-hachage. int position (ElementType x, ElementType d [ ]) { int hi, inc, dernier; hi = h (x) ; inc = g (x) ; dernier = (hi + (B-1)* inc) % B ; while ((hi != dernier) && (A [hi] {x, VIDE, ? })) { hi = (hi + inc) % B ; } return hi ; }

18 UMLV Hachage aléatoire Re-hachage :h i (x) = (h (x) + d i ) % B, d 1, d 2, …, d B-1 permutation aléatoire de (1,..., B-1) Génération des d i par « décalage ». - choix de k {1,…, B-1} 2. d i si 2. d i B-1 ( 2. d i - B) k sinon Exemple B = 8k = 5 = d 1 = 1 10 = d 2 = 2 10 = d 3 = 4 10 = d 4 = 5 10 = d 5 = 7 10 = d 6 = 3 10 = d 7 = 6 10 = d i + 1 = {

19 Hachage fermé (aléatoire) table contenant n éléments - initialisation (clear) : O (B) - probabilité d'avoir i comparaisons : - coût d'un ajout réussi, au plus n/B 50 % 80 % 90 % C n 1,39 2,01 2,56 UMLV Temps des opérations - création d'une table à n éléments (n B) C n = coût moyen d'un ajout

20 F tableau associatif : nombre fini d'indices de type quelconque F fonction de domaine fini F représentable par l'ensemble E = { (x, F [x]) / x domaine de F } Opérations - INIT (F) rendre F [x] non défini pour tout x - DEFINIR (F, x, y) poser F [x] = y - CALCULER (F, x) = ysi F [x] = y nulsinon Implémentation - représenter E par hachage sur le domaine de F UMLV Tableau associatif

21 Traducteur mot-à-mot dico if si then alors else sinon entrée text --- if --- then sortie texte --- Trad si --- alors UMLV TRADUCTEUR