Arbre d\'aa

Seulement deux opérations sont nécessaires pour l'équilibre de maintien dans un arbre d'aa. Ces opérations s'appellent obliques et fendues. Le biais est une bonne rotation quand une insertion ou une suppression crée un lien horizontal gauche, qui peut être considéré comme lien rouge gauche dans le contexte rouge-noir d'arbre. La fente est une rotation gauche conditionnelle quand une insertion ou une suppression crée deux bons liens horizontaux, qui correspondent de nouveau à deux liens rouges consécutifs dans les arbres rouge-noirs.

le oblique de la fonction est le a entré : T, un noeud représentant un arbre d'aa qui doit être rééquilibré. le a produit : un autre noeud représentant l'arbre rééquilibré d'aa. si zéro de (T) puis zéro de retour du autrement si niveau de (laissé (T)) le niveau de == (T) puis Échange de les indicateurs des liens gauches horizontaux. L = est parti (T) gauche (T) : = droit (L) droite (L) : = T de retour L d'autre de retour T extrémité de si fonction de fin de

le fendu de la fonction est le a entré : T, un noeud représentant un arbre d'aa qui doit être rééquilibré. le a produit : un autre noeud représentant l'arbre rééquilibré d'aa. si zéro de (T) puis zéro de retour du autrement si niveau de (T) == de niveau (droit (droit (T))) puis nous avons trois bons liens horizontaux. Prendre l'élément moyen, l'élever, et renvoyer cela. R = droit (T) droite (T) : = est parti (R) gauche (R) : = T niveau (R) : = de niveau (R) + 1 de retour R d'autre de retour T extrémité de si fonction de fin de

Insertion

L'insertion commence par le procédé normal de recherche et d'insertion d'arbre binaire. Puis, car la pile des appels déroule, il est facile de vérifier la validité de l'arbre et d'effectuer toutes les rotations selon les besoins. Si un lien gauche horizontal surgit, un biais sera exécuté, et si deux bons liens horizontaux surgissent, une fente sera exécutée, incrémentant probablement le niveau du nouveau noeud de racine du sous-arbre courant. Note dans le code comme donné au-dessus de l'incrément du niveau (T). Ceci le rend nécessaire de continuer de vérifier la validité de l'arbre pendant que les modifications bouillonnent vers le haut des feuilles.

le d'insertion de la fonction est le a entré : X, la valeur à insérer, et T, la racine de l'arbre pour l'insérer dans. le a produit : Version équilibrée T de A comprenant le X. Le font le procédé normal d'insertion d'arbre binaire. Placer le résultat du appel récursif à l'enfant correct au cas où un nouveau noeud était créé ou racine des changements de sous-arbre. si zéro de (T) puis Le créent un nouveau noeud de feuille avec X. noeud de retour du (X, 1, zéro, zéro) autrement si X < valeur (T) puis gauche (T) : = insertion (X, laissé (T)) autrement si X > valeur (T) puis droite (T) : = insertion (X, droite (T)) extrémité de si Note de que le cas de la valeur de == de X (T) est non spécifié. Comme donné, une insertion n'aura aucun effet. Le réalisateur peut désirer le comportement différent. Le exécutent le biais et se sont puis dédoublés. Les conditionals qui déterminent si ou pas une rotation se produira ou pas est à l'intérieur de des procédures, comme donné au-dessus de. T : = biais (T) T : = dédoubler (T) T de retour fonction de fin de

Suppression

Comme dans la plupart des arbres binaires équilibrés, la suppression d'un noeud interne peut être transformée en suppression d'un noeud de feuille en permutant le noeud interne avec son prédécesseur plus étroit ou successeur, selon lesquels être dans l'arbre ou les caprices du réalisateur. Retreiving un prédécesseur est simplement une question de suivre un lien gauche et puis tous les bons liens demeurants. De même, le successeur peut être trouvé par droite allante une fois et est parti jusqu'à ce qu'un pointeur nul soit trouvé. En raison de la propriété d'aa de tous les noeuds de plus considérablement que les de niveau ayant deux enfants, le successeur ou le noeud de prédécesseur sera dans le niveau 1, faisant leur insignifiant remoal.

Pour rééquilibrer un arbre, il y a quelques approches. Celui décrit par Andersson en son papier original est le plus simple, et il est décrit ici, bien que les réalisations réelles puissent opter pour une approche plus optimisée. Après un déplacement, la première étape à la validité de maintien d'arbre est d'abaisser le niveau de tous les noeuds dont les enfants sont deux niveaux au-dessous de eux, ou qui sont les enfants absents. Puis, le niveau entier doit être biaisé et dédoublé. Cette approche a été favorisée, parce qu'une fois fixée conceptuellement, elle a trois étapes séparées facilement compréhensibles : Diminution de

le niveau, si approprié.

Cependant, nous devons biaiser et dédoubler le niveau entier cette fois au lieu juste d'un noeud, compliquant notre code.

le de suppression de la fonction est entré : X, la valeur à supprimer, et T, la racine de l'arbre duquel il devrait être supprimé. produit : T, équilibré, sans valeur X. si X > valeur (T) puis droite (T) : = suppression (X, droite (T)) autrement si X < valeur (T) puis gauche (T) : = suppression (X, laissé (T)) d'autre Le si nous sommes une feuille, facile, autrement réduisent à la caisse de feuille. si feuille de (T) puis zéro de retour autrement si zéro de (laissé (T)) puis L : = successeur (T) droite (T) : = suppression (L, droite (T)) valeur (T) : = L d'autre L : = prédécesseur (T) gauche (T) : = suppression (L, laissé (T)) valeur (T) : = L extrémité de si extrémité de si Le rééquilibrent l'arbre. Diminuer le niveau de tous les noeuds dans ce niveau si nécessaire, et puis oblique et fendu tous les noeuds au nouveau niveau. T : = decrease_level (T) T : = biais (T) droite (T) : = biais (droit (T)) droite (droite (T)) : = biais (droit (droit (T))) T : = dédoubler (T) redresser (T) : = dédoubler (droit (T)) fonction de fin de

le de decrease_level de la fonction est entré : T, un arbre pour lequel nous veulent enlever les liens qui sautent des niveaux. produit : T avec lui est de niveau diminué. should_be = maximum (de niveau (parti (T)), de niveau (droit (droit (T)))) + 1 si should_be de < de niveau (T) puis niveau (T) : = should_be si should_be de < de niveau (bon (T)) puis niveau (juste (T)) : = should_be extrémité de si extrémité de si T de retour fonction de fin de

Un bon exemple de suppression par cet algorithme est présent dans le papier d'Andersson.

Exécution

L'exécution d'un arbre d'aa est équivalente à l'exécution d'un arbre rouge-noir. Tandis qu'un arbre d'aa fait plus de rotations qu'un arbre rouge-noir, les algorithmes plus simples tendent à être plus rapides, et toute la ceci équilibre dehors pour avoir comme conséquence l'exécution semblable. Un arbre rouge-noir est plus conformé dans son exécution qu'un arbre d'aa, mais un arbre d'aa tend à être plus plat, qui a comme conséquence des temps de recherche légèrement plus rapides.

Voir également