Arbre B

Un arbre étiqueté est un arbre (au sens informatique du terme) tel qu'à chaque nœud on associe une étiquette ou clé (ou bien plusieurs étiquettes ou clés dans le cas des arbres B) prise(s) dans un ensemble donné. Donc formellement un arbre étiqueté est un couple formé d'un graphe orienté, acyclique et connexe et d'une fonction d'étiquetage des arbres qui attribue à chaque nœud une étiquette ou une clé. Parmi les arbres étiquetés, un arbre B possède quelques propriétés spécifiques supplémentaires.

Soient L et U deux entiers naturels non nuls tels que L ≤ U. En toute généralité, on définit alors un L-U arbre B[3] de la manière suivante : chaque nœud, sauf la racine, possède un minimum de L−1 clés (appelées aussi éléments), un maximum de U−1 clés et au plus U fils[4]. Pour chaque nœud interne — nœud qui n’est pas une feuille —, le nombre de fils est toujours égal au nombre de clés augmenté d’une unité. Si n est le nombre de fils, alors on parle de n-nœud. Un L-U arbre ne contient que des n-nœuds avec L ≤ n ≤ U. Souvent on choisit la configuration L = t et U = 2 × t : t est appelé le degré minimal de l’arbre B.

De plus, la construction des arbres B garantit qu’un arbre B est toujours équilibré. Chaque clé d’un nœud interne est en fait une borne qui distingue les sous-arbres de ce nœud. Par exemple, si un nœud a 3 fils — lesquels constituent les racines respectives de trois sous-arbres : sous-arbre gauche, sous-arbre du milieu et sous-arbre droit —, alors il a 2 clés notées c₁ et c₂ qui délimitent les clés de chaque sous-arbre : les clés du sous-arbre gauche seront inférieures à c₁ ; les clés du sous-arbre du milieu seront comprises entre c₁ et c₂ ; les clés du sous-arbre droit seront supérieures à c₂.

Un arbre B est implémenté par un arbre enraciné[5]. Un nœud ${\displaystyle x}$ est étiqueté par :

• Un entier ${\displaystyle n}$ qui correspond au nombre de clefs contenues dans le nœud ${\displaystyle x}$.
• ${\displaystyle n}$ clefs notées ${\displaystyle c_{1},\ldots ,c_{n}}$.
• Un booléen indiquant si ${\displaystyle x}$ est une feuille ou non.
• ${\displaystyle n+1}$ pointeurs notés ${\displaystyle p_{1},\ldots ,p_{n+1}}$ associés aux fils ${\displaystyle f_{1},\ldots ,f_{n+1}}$ de ${\displaystyle x}$. Une feuille ne contient pas de pointeurs.

De plus, un arbre B vérifie ces propriétés :

• Toutes les feuilles ont la même profondeur, à savoir la hauteur ${\displaystyle h}$ de l’arbre.
• Si ${\displaystyle x}$ n’est pas une feuille :
  • Pour ${\displaystyle 2\leq i\leq n}$ , pour toute clef ${\displaystyle k}$ du fils ${\displaystyle f_{i}}$ : ${\displaystyle c_{i-1}\leq k\leq c_{i}}$.
  • pour toute clef ${\displaystyle k}$ du fils ${\displaystyle f_{1}}$: ${\displaystyle k\leq c_{1}}$.
  • pour toute clef ${\displaystyle k}$ du fils ${\displaystyle f_{n+1}}$ : ${\displaystyle c_{n}\leq k}$.
• Si ${\displaystyle x}$ n’est ni une feuille, ni la racine, ${\displaystyle n}$ est compris entre L-1 et U-1.

La plupart du temps, la configuration est telle que U = 2 L. On parle alors d’arbre B d'ordre L.

Un arbre B d’ordre t est alors défini plus simplement par un arbre qui satisfait les propriétés suivantes :

1. Chaque nœud a au plus ${\displaystyle 2t-1}$ clés.
2. Chaque nœud qui n’est ni racine ni feuille possède au moins ${\displaystyle t-1}$ clés.
3. Si l'arbre est non vide, la racine est aussi non vide.
4. Un nœud qui possède k fils contient k − 1 clefs.
5. Toutes les feuilles se situent à la même hauteur.

La recherche est effectuée de la même manière que dans un arbre binaire de recherche. Partant de la racine, on parcourt récursivement l’arbre ; à chaque nœud, on choisit le sous-arbre fils dont les clés sont comprises entre les mêmes bornes que celles de la clé recherchée grâce à une recherche dichotomique.

fonction Rechercher(noeud, x):
    i = 0
    tant que i < noeud.taille et x > noeud.cles[i]:
        i += 1
        
    si noeud.feuille:
        retourner x == noeud.cles[i]
    sinon:
        si x == noeud.cles[i]:
            retourner Vrai
        sinon si i == noeud.taille et x > noeud.cles[noeud.taille - 1]:
            retourner Rechercher(noeud.branches[noeud.taille], x)
        sinon:
            retourner Rechercher(noeud.branches[i], x)

Dans de nombreuses implémentations, l'égalité (${\displaystyle a==b}$) entre éléments est remplacée par l'équivalence (${\displaystyle \neg (a<b)\wedge \neg (b<a)}$). Il faut donc veiller à utiliser des types de données où deux éléments équivalents sont considérés comme égaux.

L’insertion nécessite tout d’abord de chercher le nœud où la nouvelle clé devrait être insérée, et l’insérer. La suite se déroule récursivement, selon qu’un nœud ait ou non trop de clés : s’il possède un nombre acceptable de clés, on ne fait rien ; autrement on le transforme en deux nœuds, chacun possédant un nombre minimum de clés, puis on fait « remonter » la clé du milieu qui est alors insérée dans le nœud père. Ce dernier peut du coup se retrouver avec un nombre excessif de fils ; le procédé se poursuit ainsi jusqu’à ce que l’on atteigne la racine. Si celle-ci doit être divisée, on fait « remonter » la clé du milieu dans une nouvelle racine, laquelle génèrera comme nœuds fils les deux nœuds créés à partir de l’ancienne racine, à l’instar de l'étape précédente. Pour que l’opération soit possible, on remarque qu’il faut que U ≥ 2 L ; sinon les nouveaux nœuds ne possèderont pas suffisamment de clés.

Une variante consiste à éclater préventivement chaque nœud « plein » (possédant le nombre maximal de clés) rencontré lors de la recherche du nœud où se réalisera l'insertion. De cette manière on évite une remontée dans l'arbre, puisque l'on assure que le père d'un nœud à scinder en deux peut accueillir une clé supplémentaire. La contrepartie en est une légère augmentation de la hauteur moyenne de l'arbre.

On doit d’abord chercher la clé à supprimer et la supprimer du nœud qui la contient.

• Si le nœud est interne, on procède de manière similaire aux arbres binaires de recherche en recherchant la clé k la plus à gauche dans le sous-arbre droit de la clé à supprimer ou la plus à droite dans le sous-arbre gauche. Cette clé k appartient à une feuille. On peut la permuter avec la clé à supprimer, que l’on supprime ensuite. Comme elle appartient à une feuille, on se ramène au cas suivant.
• Si le nœud est une feuille, soit il possède encore suffisamment de clés et l’algorithme termine, soit il dispose de moins de L−1 clés et on se trouve dans l’une des deux situations suivantes :
  • soit un de ses frères à droite ou à gauche possède suffisamment de clés pour pouvoir en « passer » une à la feuille en question : dans ce cas cette clé remplace la clé qui sépare les deux sous-arbres dans l’arbre père, qui va elle-même dans la feuille en question ;
  • soit aucun de ses frères n’a suffisamment de clés : dans ce cas, le père fait passer une de ses clés dans un des deux (ou le seul) frères pour permettre à la feuille de fusionner avec celui-ci. Ceci peut cependant conduire le père à ne plus avoir suffisamment de clés. On réitère alors l’algorithme : si le nœud a un frère avec suffisamment de clés, la clé la plus proche va être échangée avec la clé du père, puis la clé du père et ses nouveaux descendants sont ramenés dans le nœud qui a besoin d’une clé ; sinon on effectue une fusion à l’aide d’une clé du père et ainsi de suite. Si l’on arrive à la racine et qu’elle possède moins de L éléments, on fusionne ses deux fils pour donner une nouvelle racine.

Notamment après une suppression, l'arbre peut être rééquilibré. Cette opération consiste à répartir équitablement les valeurs dans les différents nœuds de l'arbre et à rétablir les propriétés de remplissage minimum des nœuds.

Le rééquilibrage commence au niveau des feuilles et progresse vers la racine, jusqu'à celle-ci. La redistribution consiste à transférer un élément d'un nœud voisin qui possède suffisamment de valeurs vers le nœud qui en manque. Cette redistribution est appelée rotation. Si aucun voisin ne peut fournir de valeur sans être lui même sous la limite, le nœud déficient doit être fusionné avec un voisin. Cette opération provoque la perte d'un séparateur dans le nœud parent, celui-ci peut alors être en déficit et a besoin d'être équilibré. La fusion et redistribution se propage jusqu'à la racine, seul élément où la déficience en valeurs est tolérée.

Un algorithme d'équilibrage simple consiste à:

• Si le nœud voisin gauche existe et dispose de suffisamment de valeurs pour pouvoir en offrir une, réaliser une rotation gauche.
• Sinon, si le nœud voisin droite existe et dispose de suffisamment d'éléments, réaliser une rotation droite.
• Sinon, le nœud déficient doit être fusionné avec un de ses voisins tel que la somme du nombre de leurs clés plus 1 soit inférieure ou égale à la capacité maximale (${\displaystyle taille_{gauche}+taille_{droite}+1\leq U-1}$). La valeur supplémentaire correspond au séparateur présent dans le parent. Cette opération est toujours possible si ${\displaystyle U-1\geq 2\times L}$ avec ${\displaystyle taille_{gauche}=L-2}$ et ${\displaystyle taille_{droite}=L-1}$ ou le contraire, soit un nœud immédiatement sous la limite de ${\displaystyle L-1}$ clés et un nœud exactement à la limite.
  1. copier le séparateur à la fin du nœud de gauche
  2. ajouter tous les éléments du nœud de droite à la fin du nœud de gauche
  3. effacer le nœud de droite et effacer le séparateur du parent puis vérifier qu'il contient assez d'éléments. Si ce n'est pas le cas, rééquilibrer le parent avec ses voisins.

La rotation à gauche d'un cran entre deux nœuds voisins se fait en

1. déplaçant le séparateur, présent dans le parent, à la fin du nœud de gauche
2. déplaçant le premier élément du nœud de droite en tant que séparateur dans le parent

Ce genre d'opération peut être également utilisé pour compresser l'arbre: un arbre destiné à la lecture seule peut être vidé d'un maximum de cases mémoires inutilisées en remplissant au maximum un minimum de nœuds.

• (en) cs.usfca.edu : animation permettant d'insérer et de supprimer visuellement des éléments dans un arbre B
• (it) (en) B-tree GUI : Spataro Fabrizio e Todaro Michelangelo – Emulatore Java BTree – BTree Java Emulator.
• (en) Slady.net : animation sous forme d’applet Java permettant de construire visuellement des arbres B.

• Portail de l'informatique théorique