AccueilđŸ‡«đŸ‡·Chercher

Arbre de Van Emde Boas

Un arbre de Van Emde Boas, aussi appelĂ© une file de prioritĂ© de Van Emde Boas prononcĂ© en nĂ©erlandais : [vɑn 'ɛmdə 'boːɑs]), connu aussi sous le nom arbre vEB, est une structure de donnĂ©es sous forme d'arbre qui implĂ©mente un tableau associatif avec des clĂ©s formĂ©es d'entiers Ă  m bits. Elle rĂ©alise toutes les opĂ©rations en temps ou, de maniĂšre Ă©quivalente, en temps , oĂč est le plus grand nombre d'Ă©lĂ©ments que peut contenir l'arbre. Il ne faut pas confondre avec le nombre d'Ă©lĂ©ments effectivement prĂ©sents dans l'arbre, nombre qui sert, dans d'autres structures de donnĂ©es, Ă  mesurer l'efficacitĂ© de la structure. Un arbre vEB a de bonnes performances quand il contient beaucoup d'Ă©lĂ©ments. La structure de donnĂ©es a Ă©tĂ© inventĂ©e par l'informaticien thĂ©oricien nĂ©erlandais Peter van Emde Boas en 1975[1] - [2] - [3].

Arbre de Van Emde Boas
Un exemple d'arbre de Van Emde Boas. Dans cet exemple, top est noté aux.
DĂ©couvreur ou inventeur
Date de découverte
Complexité en temps
Pire cas
Moyenne
Meilleur cas
Complexité en espace
Pire cas
Moyenne
Meilleur cas

Structure

Les clĂ©s utilisĂ©es dans un arbre vEB sont des entiers de bits, donc des entiers compris entre 0 et , oĂč . Ce nombre est aussi le nombre maximal de donnĂ©es contenues dans un tel arbre. On suppose, pour simplifier, que lui-mĂȘme est une puissance de 2.

Un arbre vEB T de taille , à clés dans , est composé

  • d'un arbre vEB de taille appelĂ© le « sommaire », ou « top » et notĂ© T.top
  • d'un tableau, notĂ© aussi « bottom », de arbres « feuilles » vEB de taille , indicĂ© par les entiers de , notĂ©s T.bottom[0], etc., T.bottom[].

L'arbre sommaire et les arbres feuilles sont de taille et ont pour clĂ©s des entiers de bits, composĂ©s Ă  partir des clĂ©s pour l'arbre T : Si est un entier sur bits, alors , oĂč est l'entier Ă©crits sur les bits de poids fort de , et l'entier reprĂ©sentĂ© par les bits de poids faible. Les entiers et sont aussi notĂ©s de maniĂšre plus fonctionnelle hi(x) et lo(x). L'arbre sommaire contient, pour , un pointeur vers l'arbre feuille d'indice , si cet arbre n'est pas vide, et la valeur associĂ©e Ă  la clĂ© dans l'arbre feuille est la valeur cherchĂ©e. Ainsi, la valeur associĂ©e Ă  x dans T est la valeur associĂ©e Ă  dans l'arbre T.bottom[a], ou encore T.bottom[hi(x)].lo(x).

De plus, un arbre vEB T maintient deux valeurs et qui contiennent la plus petite et la plus grande valeur présente dans l'arbre. Ces valeurs ne figurent pas ailleurs dans l'arbre. Si l'arbre est vide, on pose et . Une variante consiste à maintenir un champ additionnel T.taille qui simplifie ce test.

Opérations

Un arbre vEB réalise les opérations d'un tableau associatif ordonné, ce qui comprend les opérations usuelles d'un tel tableau, et deux autres opérations, relatives à l'ordre, qui sont suivant et précédent[4] qui donnent l'élément immédiatement supérieur respectivement inférieur présent dans l'arbre ; en plus les opérations minimum et maximum retournent respectivement le plus petit et le plus grand élément contenu dans l'arbre. Ces deux éléments sont trouvés en temps constant O(1), parce qu'ils figurent à des emplacements séparés dans l'arbre[5].

  • insĂ©rer : insĂšre la paire (clĂ©,valeur) ;
  • supprimer : supprime la paire (clĂ©,valeur) donnĂ©e par la clĂ© ;
  • chercher : retourne la valeur associĂ©e Ă  une clĂ© donnĂ©e ;
  • suivant : retourne la paire (clĂ©, valeur) avec la plus petite clĂ© strictement supĂ©rieure Ă  la clĂ© donnĂ©e ;
  • prĂ©cĂ©dent : retourne la paire (clĂ©, valeur) avec la plus petite clĂ© strictement infĂ©rieur Ă  la clĂ© donnĂ©e ;
  • minimum : retourne la plus petite valeur contenue dans l'arbre ;
  • maximum : retourne la plus grande valeur contenue dans l'arbre .

Détail des opérations

Suivant

L'opĂ©ration suivant(T, x) cherche le successeur de x dans l'arbre : On test d'abord si x est infĂ©rieur Ă  l'Ă©lĂ©ment minimum ou supĂ©rieur Ă  l'Ă©lĂ©ment maximum dans l’arbre. Dans le premier cas, le successeur est T.min, dans le deuxiĂšme cas, il n'y a pas de successeur et la rĂ©ponse est M. Sinon, on pose x = a + b, avec a= hi(x) et b=lo(x), et on teste si b est plus petit que le maximum de l'arbre feuille T.bottom[a] ; dans l'affirmative, on la cherche rĂ©cursivement dans ce sous-arbre, mais avec le paramĂštre b. Sinon, le successeur est le min de l'arbre T.bottom[c], oĂč c est le suivant de a dans l'arbre sommaire ; on cherche dans l'arbre suivant dans le sommaire et on retourne son plus petit Ă©lĂ©ment.

Formellement :

fonction suivant(T, x).
    si x < T.min alors
        retourner T.min
    si x ≄ T.max alors 
        retourner M
    poser x = a + b
    si b < T.bottom[a].max alors
        retourner a + suivant(T.bottom[a], b)
    sinon
        c = suivant(T.top,a+1);
        retourner c + T.bottom[c].min
end

La fonction effectue un nombre constant d'opĂ©rations avant un Ă©ventuel appel rĂ©cursif avec un paramĂštre dont la taille est la racine carrĂ©e. Ceci donne pour le temps de calcul la formule , d'oĂč un temps en O(log m) = O(log log M).

Insertion

L'appel insérer(T, x) insÚre la valeur x dans l'arbre vEB T, comme suit :

Si T est vide ou contient un seul élément, l'insertion ne pose pas de problÚme (sauf qu'ils rallongent le code). Dans les autres cas, il y a deux étapes :

  1. Si , on Ă©change x et , de mĂȘme pour et
  2. Ensuite, on procÚde à la véritable insertion : avec , on cherche l'entrée pour a dans l'arbre sommaire, et si elle n'existe pas, on la crée, puis on insÚre la clé b dans l'arbre feuille.

Formellement :

fonction insérer(T, x)
    si T est vide alors
        T.min = T.max = x;
        retourner
    si T est un singleton alors
        si x < T.min alors T.min = x
        si x > T.max alors T.max = x
    si x < T.min alors
        Ă©changer(x, T.min)
    si x > T.max alors
        Ă©changer(x, T.max)
    poser x = a + b
    si T.bottom[a] est vide alors
      insérer(T.top,a)
    insérer(T.bottom[a] , b))
end

La clĂ© pour l'efficacitĂ© de cette procĂ©dure est le fait que l’insertion d'un Ă©lĂ©ment dans un arbre vEB vide prend un temps constant. Ainsi, mĂȘme quand l'algorithme fait deux appels rĂ©cursifs, le premier de ces appel consiste en l'insertion dans un sous-arbre vide et prend un temps constant. Ceci donne Ă  nouveau la relation de rĂ©currence comme ci-dessus et donc un temps en O(log log M)..

Suppression

La suppression est, comme toujours, l'opération la plus délicate. L'appel supprimer(T, x) qui supprime x de l'arbre vEB T opÚre comme suit :

  1. Si x est le seul Ă©lĂ©ment prĂ©sent dans T, on pose et pour indiquer que l’arbre rĂ©sultant est vide.
  2. Sinon, si x = T.min, on cherche la valeur immĂ©diatement supĂ©rieure y dans l'arbre, on l'enlĂšve de sa place et on pose T.min=y. La valeur y est T.max si l’arbre est un singleton, ou la plus petite valeur du premier des arbres prĂ©sents dans le sommaire, soit T.bottom[T.top.min].min, et elle peut donc ĂȘtre trouvĂ©e en temps constant ; on opĂšre de maniĂšre symĂ©trique si x = T.max ; on cherche la valeur immĂ©diatement infĂ©rieure y dans l'arbre et on pose T.max=y. La valeur y immĂ©diatement infĂ©rieure est T.min (si l’arbre est un singleton) ou T.bottom[T.top.max].max.
  3. Si x≠T.min et x≠T.max on supprime x dans le sous-arbre T.bottom[a] qui contient x.
  4. Enfin, dans tous les cas, si on supprime un élément dans un sous-arbre singleton, on supprime aussi le sous-arbre.

Formellement :

fonction supprimer(T, x)
    si T.min = T.max = x alors
        T.min = M ; T.max = −1
        retourner
    si x = T.min alors
        T.min = T.bottom[T.top.min].min
        retourner
    si x = T.max alors
        T.max = T.bottom[T.top.max].max
        retourner
   poser x = a + b
    supprimer(T.bottom[a], b)
    si T.bottom[a] est vide then
        supprimer(T.top, a)
end

À nouveau, l'efficacitĂ© de la procĂ©dure provient du fait que la suppression dans un arbre vEB rĂ©duit Ă  un singleton prend un temps constant.

Discussion

L'hypothÚse que m est une puissance de 2 n'est pas indispensable : le fonctions hi(x) et lo(x) peuvent aussi bien retourner l'entier formé des plus forts bits et des plus faibles bits de x,sans changer l'algorithme et son évaluation en temps.

L'implémentation décrite ci-dessus occupe une place en O(M) = O(2m). La formule de récurrence pour la place prise par un arbre vEB est

,

ou, en posant ,

pour une constante . Une résolution directe de , avec , donne

ce qui prouve, aprĂšs quelques ajustements, que [6].

Pour des petits arbres, la place additionnelle requise est importante puisqu'elle les linĂ©aire en fonction de la taille maximale, et non de la taille effective. D'autres variantes ont Ă©tĂ© proposĂ©es pour ces cas, comme les tries. On peut aussi remplaces les tables par une table de hachage, ce qui rĂ©duit la place Ă  O(n log M), pour n Ă©lĂ©ments contenus dans la structure aux dĂ©pens d'un coĂ»t alĂ©atoire. Les arbres de van Emde Boas peuvent ĂȘtre randomisĂ©s pour obtenir une majoration en espace en au lieu de [6], en remplaçant les tables bottom par des tables de hachage. Une telle modification occupe une place en . Mais si on utilise bits par entrĂ©e dans la table de hachage au i-Ăšme niveau de rĂ©cursion, la structure ne prend qu'un place en . Si un hachage dynamique parfait est employĂ©, les recherches se font toujours en dans le pire des cas, mais les insertions et suppressions prennent un temps amorti moyen en.

D'autres structures, y compris les Y-fast trie (en) et les X-fast trie (en) ont Ă©tĂ© proposĂ©es ; elles ont des complexitĂ©s en temps comparable pour les requĂȘtes et les modifications, et utilisent aussi des tables de hachage pour rĂ©duire la complexitĂ© en place.

Notes et références

(en) Cet article est partiellement ou en totalitĂ© issu de l’article de WikipĂ©dia en anglais intitulĂ© « Van Emde Boas tree » (voir la liste des auteurs).
  1. Peter van Emde Boas, « Preserving order in a forest in less than logarithmic time », Foundations of Computer Science (Conference Proceedings,‎ , p. 75-84 (ISSN 0272-5428, DOI 10.1109/SFCS.1975.26).
  2. Peter van Emde Boas, « Preserving order in a forest in less than logarithmic time and linear space », Information Processing Letters, vol. 6, no 3,‎ , p. 80–82 (ISSN 0020-0190, DOI 10.1016/0020-0190(77)90031-X).
  3. Peter Van Emde Boas, R. Kaas et E. Zijlstra, « Design and implementation of an efficient priority queue », Mathematical Systems Theory, vol. 10,‎ , p. 99–127 (DOI 10.1007/BF01683268l, prĂ©sentation en ligne)
  4. Gudmund Skovbjerg Frandsen, « Dynamic algorithms: Course notes on van Emde Boas trees », University of Aarhus, Department of Computer Science.
  5. (en) Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest et Clifford Stein, Introduction to Algorithms, Cambridge (Mass.), MIT Press, , 3e Ă©d., xix+1312 (ISBN 978-0-262-03384-8, 978-0-262-53305-8 et 9780262259460, SUDOC 136281273, prĂ©sentation en ligne), « Chapter 20: The van Emde Boas tree », p. 531–560
  6. A. Rex, « Determining the space complexity of van Emde Boas trees ».

Voir aussi

Bibliographie

De nombreux cours sont accessibles, notamment :

Filmographie

Articles connexes


Cet article est issu de wikipedia. Text licence: CC BY-SA 4.0, Des conditions supplĂ©mentaires peuvent s’appliquer aux fichiers multimĂ©dias.