SOMMAIRE

INTRODUCTION ....................................................................................................................................... 1
I- GENERALITES SUR LES B-trees.............................................................................................................. 2
1. Historique : .................................................................................................................................. 2
2. Présentation d’un B-tree : ........................................................................................................... 2
II- MECANISME DE FONCTIONNEMENT D’UN B-TREE :........................................................................... 4
1. Insertion dans un B-tree : ............................................................................................................ 4
2. Suppression dans un B-tree :....................................................................................................... 7
3. Fonctions des B-trees : ................................................................................................................ 9
d. Equalimage : .............................................................................................................................. 11
e. Options : ................................................................................................................................... 13
IV- AVANTAGES ET DOMAINES D’APPLICATION DES B-Trees : ............................................................. 13
1. Avantages : ................................................................................................................................ 13
2. Domaines d’applications : ......................................................................................................... 14
V-EXEMPLES :......................................................................................................................................... 15
1-L’implementation d’un B-tree en C++ : ........................................................................................... 15
2- Explication du bout de code : ................................................................................................... 15
CONCLUSION ......................................................................................................................................... 15
BIBLIOGRAPHIE ET WEBOGRAPHIE ....................................................................................................... 16

I
II
INTRODUCTION

B-Tree est un arbre de recherche auto-équilibré. Dans la plupart des autres arbres de
recherche auto-équilibrés (comme AVL et Red-Black Trees), on suppose que tout est
dans la mémoire principale. Pour comprendre l’utilisation des B-Trees, nous devons
penser à l’énorme quantité de données qui ne peuvent pas tenir dans la mémoire
principale. Lorsque le nombre de clés est élevé, les données sont lues sur le disque
sous forme de blocs. Le temps d’accès au disque est très élevé par rapport au temps
d’accès à la mémoire principale. L’idée principale de l’utilisation des B-Trees est de
réduire le nombre d’accès au disque. La plupart des opérations d’arborescence
(recherche, insertion, suppression, max, min,,etc.) nécessitent des accès disque O(h)
où h est la hauteur de l’arborescence. B-tree est un arbre gras. La hauteur des B-Trees
est maintenue faible en plaçant le maximum de clés possibles dans un node B-Tree.
Généralement, la taille du node B-Tree est maintenue égale à la taille du bloc de
disque.

1
I- GENERALITES SUR LES B-trees

1. Historique :

Le créateur des arbres B, Rudolf Bayer, n'a pas explicité la signification du « B».
L'explication la plus fréquente est que le B correspond au terme anglais « balanced » (en
français : « équilibré »). Cependant, il pourrait aussi découler de « Bayer », du nom du créateur,
ou de « Boeing », du nom de la firme pour laquelle le créateur travaillait (Boeing Scientific
Research Labs). Les arbres B ont été inventés en 1970 par Rudolf Bayer et Edward McCreight
dans les laboratoires de recherche de Boeing. Le but était de pouvoir gérer les pages d'index
de fichiers de données, en tenant compte du fait que le volume des index pouvait être si grand
que seule une fraction des pages pouvait être chargée en mémoire vive. Le premier article
décrivant le mécanisme des arbres B a été écrit en juillet et publié en novembre 1970.

2. Présentation d’un B-tree :

a. Définition :
Un B-arbre est un arbre de la recherche avec une ramification importante et une hauteur
plutôt faible. En pratique un nœud de notre arbre est une page de notre disque externe.

Hypothèses : on se donne deux opérations atomiques : ECRITURE-DISQUE et LECTURE-

DISQUE (on ne peut pas les découper en sous fonctions, elles travaillent uniquement sur une
page du disque dur). On veut montrer l’optimalité de la structure de donnée face à l’utilisation
de ces deux opérations.

Définition d’un B-arbre et exemple :

Définition : Un B-arbre est un arbre T possédant les propriétés suivantes :
1. Chaque nœud x contient les attributs ci-après :
(a) x.n le nombre de clés conservées dans le nœud (le nœud est alors d’arité n + 1) ;
(b) Les x.n clés x.cle1, . . ., x.clen stockées dans un ordre croissant (structure de donnée
associée : liste) ;
(c) Un booléen, x.feuille marquant si le noeud est une feuille ;
(d) Les n + 1 pointeurs des fils, {x.c1, . . . x.cn+1} ;
2. Les clés et les valeurs dans les arbres fils vérifient la propriété suivante : k0 ≤ x. cle1 ≤...
≤ x. clen ≤ kn ;
3. Toutes les feuilles ont la même profondeur, qui est la hauteur h de l’arbre ;
4. Le nombre de clé d’un nœud est contenu entre t − 1 ≤ n ≤ 2t − 1. (Pour la racine on n’a
que la borne supérieure, la borne inférieure est 1 : on demande qu’il y ait au moins une
clé dans la racine) où t est le degré minimal du B-arbre.
Remarque : Dans la vrai vie, t est choisi en fonction du nombre de tuples que peut contenir
une page du disque.
Théorème : Si n ≥ 1, alors pour tout B-arbre T à n clés de hauteur h et de degré minimal
𝑛+1
𝑡 ≥ 2, ℎ ≤ 𝑙𝑜𝑔2 ( 2
).

2
On montre par récurrence sur la hauteur de l’arbre que :
ℎ

𝑛 ≥ 1 + (𝑡 − 1) ∑ 2𝑡𝑖 − 1 = 2𝑡ℎ − 1
𝑖=1
ℎ 𝑛+1
D’où 𝑡 ≤ et on conclut en passant au logt .
2

GMPX

ACDE YZ

Figure 1

Hypothèses :
 La racine du B-arbre se trouve toujours en mémoire principal : on n’a pas de LIRE
DISQUE ; cependant, il faudra effectuer un ÉCRITURE-DISQUE lors de la modification de la
racine.
 Tout nœud passé en paramètre devra subir un LIRE-DISQUE.

b. Présentation :

C F L O

A B D E G H J K M N P Q S T

Figure 2
Dans la technique du B-Tree, les clés sont regroupées par pages (dans l’exemple, 4 clés par
page d’où B-Tree d’ordre 5. Il ne faut pas confondre l’ordre du B-Tree et le nombre de clés par
page). Le nombre de clés par page joue un rôle significatif dans les performances globales du
système. Un nombre peu élevé conduit à de nombreux accès car la recherche d’une clé se
traduit avant tout par une recherche dans l’arborescence des pages. Un nombre de clé trop
élevé de clés par page conduit à une importante occupation de la mémoire. Dans chaque
page, les clés sont classées dans un ordre croissant. Les pages sont organisées en arbre,
chaque page constituant un nœud. La gestion de l’arbre est réalisée par une technique
3
permettant de conserver l’arbre balancé, sans opération spécifique de réorganisation. Pour
maintenir l’arbre des pages balancé quelle que soit la nature des opérations effectuées
(insertion et suppression), les règles suivantes doivent être respectées. Elles définissent les
propriétés de base de B-Tree :
- Règle 1 : chaque page possède au plus p pointeurs, soit p pages filles. On parle de B-Tree
d’ordre p.
- Règle 2 : chaque page excepté la page racine et les pages terminales, possède au plus p/2
pages filles (attention cette règle est valable dans le processus de suppression d’une clé, c’est
la règle de déclenchement de la fusion de la page avec une page sœur).
- Règle 3 : la page racine possède au moins deux pages filles, sauf lorsqu’elle se trouve au
niveau terminal. C’est le cas au début de la création de l’arbre.
- Règle 4 : toutes les pages terminales (les pages sans pages filles) apparaissent au même
niveau. - Règle 5 : une page non terminale possédant k pages filles contient (k-1) clés.

II- MECANISME DE FONCTIONNEMENT D’UN B-TREE :

1. Insertion dans un B-tree :

L'insertion d'un élément dans un B-tree se compose de deux événements : la recherche du

nœud approprié pour insérer l'élément et la division du nœud si nécessaire. L'opération
d'insertion a toujours lieu dans l'approche ascendante. Examinons la figure 2 et demandons-
nous comment nous procéderons pour insérer une nouvelle clé dans une telle structure de
données.
Conceptuellement, nous avons deux cas à considérer selon que la page impliquée est déjà
pleine ou non.
Si la page concernée n’est pas pleine, la nouvelle clé est simplement insérée au bon endroit,
en décalant si besoin, les autres clés de la page. L’insertion de la clé « JJ », par exemple,
s’effectue en plaçant celle-ci entre la clé « J » et la clé « K ».
Voici la page initiale : J | K et la même page après l’insertion de la clé « JJ » : J | JJ | K.
Si en revanche la page concerné est plaine, le problème devient un peu plus complexe.
Tentons l’insertion de la clé « R ». Elle doit prendre place entre la clé « Q » et la clé « S ».
Cela nous conduirait à une page contenant 5 clés avec « R » comme clé médiane :
P|Q|R|S|T
Dans la pratique, la méthode va consister à construire une page de travail contenant 5 clés.
A partir de cette page de travail, il faudra construire deux pages réelles. La première de ces
pages recevra les deux clés situées à gauche de la clé médiane ; la seconde recevra les deux
clés situées à droite de la clé médiane. Quant à la clé médiane, elle devra être insérée dans
la page de niveau immédiatement supérieur, c’est à dire la page mère. S’il n’existe pas de
page mère, la clé médiane est placée dans une page créée à cette occasion ; cette page
devient la page racine.

4
Il se peut que la page mère qui recevra la clé médiane soit elle-même pleine. Elle est alors,
à son tour, traitée selon le processus que nous venons d’expliquer, à savoir :

- Construction d’une page de travail contenant 5 clés ;

- Insertion de la nouvelle clé dans la page de travail ;
- Scission de la page de travail en deux pages de deux clés chacune ; la première
page reçoit les deux clés situées à gauche de la clé médiane, et la seconde, celles
situées à droite de la clé médiane ;
- Report de la clé médiane dans la page de niveau supérieur, c’est à dire la page
mère, s’il en existe une.

Voici le résultat obtenu après l’insertion des clés « JJ » et « R » cf. Figure 3.

C F L O R

A B D E G H J JJ K M N P Q S T

Figure 3

On constate que l’arbre est toujours parfaitement balancé.

Pour parfaire l’analyse du processus d’insertion, ajoutons les clés « JJJ » et « KK »

dans un premier temps. Voici l’arbre après l’ajout de la clé « JJJ ».

C F L O R

A B D E G H J JJ JJJ K M N P Q S T

Figure 4

5
 I

C F JJJ L O R

A B D E G H J JJ K KK M N P Q S T

Figure 5
Voici l’arbre après l’ajout de la clé « KK ».

Ajoutons encore les clés « MM », « NN »

et « NNN ». Voici l’arbre après l’ajout des
clés « MM » et « NN ».
I

C F JJJ L O R

A B D E G H J JJ K KK M MM N NN P Q S T

Figure 6

Et enfin l’arbre après l’ajout de la clé « NNN ».

I N

C F JJJ L O R

A B D E G H J JJ K KK M MM NN NNN P Q S T

Figure 7

Nous avons dû faire remonter de manière successive la clé médiane car la page mère était
déjà pleine. Dans le cas où la page mère est la page racine, celle-ci sera scindée et la clé
médiane sera remontée au sein d’une nouvelle page qui deviendra la page racine.

6
 2. Suppression dans un B-tree :

Le processus de suppression d’une clé dans une structure de type B-Tree présente une réelle
complexité que nous allons nous efforcer d’éclairer.
La première phase du procédé de suppression utilise directement la technique de suppression
dans un arbre binaire simple. Dans cette technique, nous recherchions la première clé
supérieure possédant un pointeur gauche à NULL, ce qui revenait à rechercher la première
clé immédiatement supérieure. La clé trouvée venait se substituer à la clé à supprimer.
Dans la première phase de la suppression, nous commencerons donc par examiner si la clé
à supprimer possède ou non un pointeur sur des clés supérieures.
Si elle n’en possède pas, la page est simplement tassée vers la gauche et le nombre de clés
dans celle-ci est simplement réduit de 1.
Si elle possède des clés supérieures, la clé doit être remplacée par la plus petite des clés qui
lui sont supérieures, la page dans laquelle nous avons extrait cette clé doit alors être tassée
vers la gauche et son nombre de clé réduit de 1.
On constate que quel que soit le cas de figure, la première phase se traduit toujours par le
tassement d’une page.

Nous entrons ensuite dans la seconde phase du processus de suppression. Cette opération
intervient toujours après la phase de tassement d’une page et porte sur cette page. On va
effectuer une tentative de fusion entre cette page, la clé mère et la page sœur de gauche.
Suite à cette fusion, nous devons déterminer si oui ou non il y a lieu de procéder à une scission
de la page constituée.
Voici la règle qui le détermine :
Le test porte sur le nombre de clés dans la page sœur + le nombre de clés dans la page tassée
+ clé mère (1).
Si le résultat est < NUMORDRE : Le processus de suppression est terminé.
Si le résultat > NUMORDRE –1 : Une opération de scission doit être effectuée.
Arbre avant la suppression de la clé « C »
I

C F L O

A B D E G H J K M N P Q S T

Figure 8

Première étape, on remplace la clé « C » par la clé « D » immédiatement supérieure et on

effectue le tassement de la page contenant la clé « D ».

7
 I

3
D F L O

A B E G H J K M N P Q S T
1 2
Figure 9

La première phase de la suppression est terminée, on va maintenant entrer dans la seconde

phase qui consiste à tenter une fusion entre la page 1, la page 2 et la clé 3. Le résultat de
cette fusion nous donne une page contenant les clés suivantes : A | B | D | E
Cette page sera ensuite rattachée à la page contenant la clé 3 par le pointeur sur la page aux
clé inférieures.
3 I

1 2
F L O

A B D E G H J K M N P Q S T

Figure 10

Nous nous trouvons actuellement au niveau de la page 1, nous allons à présent tenter une
fusion entre la page 1, la page 2 et la page 3. Le résultat de cette fusion nous donne la page
contentant les clés suivantes ; F | I | L | O. Voici l’arbre après la fusion de ces trois pages :

F I L O

A B D E G H J K M N P Q S T

Figure 11

L’arbre reste toujours parfaitement balancé.

Si le résultat de la fusion entre les pages 1, 2 et 3 avait donné plus de 4 clés, on serait entré
dans le processus de scission final qui aurait conduit à la création d’une nouvelle page au
niveau racine avec la remontée de la clé médiane.

8
 3. Fonctions des B-trees :

Le B-tree définit une fonction de support obligatoire et quatre facultatives. Les cinq méthodes
définies sont :

a. Order :

Pour chaque combinaison de types de données pour laquelle une famille d'opérateur b-
tree fournit des opérateurs de comparaison, elle doit fournir une fonction de support de
comparaison inscrite dans pg_amproc avec la fonction de support et
amproclefttype/amprocrighttype égaux aux types de données gauche et droit pour la
comparaison (c'est-à-dire les mêmes types de données que l'opérateur correspondant a inscrit
dans pg_amop). La fonction de comparaison doit prendre en entrée deux valeurs non nulles
A et B et retourner une valeur int32 qui est < 0, 0, ou > 0 quand, respectivement A < B, A = B,
ou A > B. Une valeur de retour NULL est également interdite : toutes les valeurs du type de
données doivent être comparables. Voir src/backend/access/nbtree/nbtcompare. pour plus
d'exemples.

Si les valeurs comparées sont d'un type avec collation, l'identifiant de collation approprié sera
passé à la fonction de support de comparaison, en utilisant le mécanisme standard
PG_GET_COLLATION ().

b. Sort support :
De manière facultative, une famille d'opérateur b-tree peut fournir une ou plusieurs
fonctions sort support, inscrites comme fonctions de support numéro 2. Ces fonctions
permettent d'implémenter des comparaisons dans l'optique de tri de manière plus efficace
qu'appeler naïvement la fonction de support de comparaison. Les API impliquées pour cela
sont définies dans src/include/utils/sortsupport.h.

c. -in_range :
De manière facultative, une famille d'opérateur b-tree peut fournir une ou plusieurs
fonctions de support in_range inscrites comme fonction de support numéro 3. Celles-ci ne sont
pas utilisées durant les opérations d'index b-tree ; mais plutôt, elles étendent les sémantiques
de la famille d'opérateur de telle manière qu'elles puissent supporter les clauses de fenêtrage
contenant les types de limite de cadre RANGE décalage PRECEDING et RANGE décalage
FOLLOWING. Fondamentalement, les informations supplémentaires fournies sont comment
additionner et soustraire une valeur d'un décalage d'une manière qui est compatible avec le
tri de données de la famille.

9
Une fonction in_range doit avoir la signature

in range (val type1, base type1, offset type2, sub bool, less bool)

Return bool

« Val » et « « base » doivent être du même type, qui est un des types supportés par la famille
d'opérateurs (c'est-à-dire un type pour lequel elle fournit un tri). Cependant, offset peut être
d'un type de données différent, qui peut par ailleurs ne pas être supporté par la famille. Un
exemple est que la famille time_ops incluse par défaut fournit une fonction in_range qui a un
offset de type interval. Une famille peut fournir des fonctions in_range pour n'importe quels
des types de données qu'elle supporte, et un ou plusieurs types offset. Chaque fonction
in_range devrait être inscrite dans pg_amproc avec amproclefttype égal à type1 et
amprocrighttype égal à type2.

Les sémantiques essentielles pour une fonction in_range dépendent des deux paramètres de
drapeau booléens. Elle devrait ajouter ou soustraire base et offset, puis comparer val au
résultat, comme ceci :

Si sub et !less, renvoyer val >= (base + offset)

Si sub et less, renvoyer val <= (base + offset)

Si sub et !less, renvoyer val >= (base - offset)

Si sub et less, renvoyer val <= (base - offset)

Avant de procéder, la fonction devrait vérifier le signe d’offset : s'il est inférieur à zéro,
lever l'erreur ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE (22013) avec un
message d'erreur tel que « taille précédente ou suivante invalide dans la fonction de fenêtrage
». (Cela est requis par le standard SQL, bien que des familles d'opérateur non standards
pourraient peut-être choisir d'ignorer cette restriction, puisqu'il n'y a pas vraiment de nécessité
de sémantique dans ce cas.) Cette exigence est déléguée à la fonction in_range si bien que
le code du moteur n'a pas besoin de comprendre ce que « inférieur à zéro » signifie pour un
type de données particulier.

Une autre attente est que les fonctions in_range devraient, si applicable, éviter de
générer une erreur si base + offset ou base - offset devait causer un débordement. Le résultat
de comparaison correct peut être déterminé même si cette valeur devait être en dehors de
l'intervalle des valeurs du type de données. Notez que si le type de données inclut des
concepts tels que « infinity » ou « NaN », des précautions supplémentaires pourraient être
nécessaires pour s'assurer que les résultats de in_range soient en accord avec l'ordre de tri
normal de la famille d'opérateur.
10
 Les résultats de la fonction in_range doivent être cohérents avec l'ordre de tri imposé
par la famille d'opérateur. Pour être précis, pour n'importe quelles valeurs fixées de offset et
sub, alors :

Si in_range avec less = true est vrai pour certains val1 et base, il doit être vrai pour
chaque val2 <= val1 avec le même base.

Si in_range avec less = true est faux pour certains val1 et base, il doit être faux pour
chaque val2 >= val1 avec le même base.

Si in_range avec less = true est vrai pour certains val et base1, il doit être vrai pour
chaque base2 >= base1 avec le même val.

Si in_range avec less = true est faux pour certains val et base1, il doit être faux pour
chaque base2 <= base1 avec le même val.

Des déclarations similaires avec des conditions inversées continuent à s'appliquer

quand less = false.

Si le type est trié (type1) par rapport à une collation, l'OID de collation appropriée sera
passé à la fonction in_range en utilisant le mécanisme standard PG_GET_COLLATION ().

Les fonctions in_range n'ont pas besoin de gérer les valeurs en entrée NULL, et
typiquement elles seront marquées comme strict.

d. Equalimage :
Une famille d'opérateurs b-tree facultative peut fournir les fonctions de support
equalimage (« l'égalité implique une égalité d'image »), inscrites comme fonctions de support
numéro 4. Ces fonctions permettent au code du moteur de déterminer quand il est sûr
d'appliquer l'optimisation de dédoublonnage b-tree. Actuellement, les fonctions equalimage
sont seulement appelées lors de la construction ou reconstruction d'un index.

Une fonction equalimage doit avoir comme signature : « equalimage(opcintype oid)

returns bool »

La valeur retournée est une information statique relative à une classe d'opérateur et
une collation. Retourner true indique que la fonction order pour la classe d'opérateur est
garantie de retourner seulement 0 (« les arguments sont égaux ») quand ses arguments A et
B sont aussi interchangeables sans aucune perte d'information sémantique. Ne pas inscrire
une fonction equalimage ou retourner false indique que cette condition ne peut être tenue.

11
 L'argument opcintype est le pg_type.oid du type de données que la classe d'opérateur
indexe. Ceci est une commodité qui permet de réutiliser la même fonction equalimage sous-
jacente entre plusieurs classes d'opérateurs. Si opcintype est un type de données collationné,
l'identifiant de collation appropriée sera passé à la fonction equalimage, par le mécanisme
standard PG_GET_COLLATION ().

Tant que la classe d'opérateur est concernée, retourner true indique que le
dédoublement est sûr (ou sûr pour la collation dont l'identifiant a été passé à sa fonction
equalimage). Cependant, le code du moteur considérera le dédoublonnage sécurisé pour un
index, si chaque colonne indexée utilise une classe d'opérateur ayant inscrit une fonction
equalimage, et si chaque fonction retourne true par appel.

L'égalité d'image est presque la même condition qu'une simple égalité bit à bit. Il n'y a
qu'une seule et subtile différence : en indexant un type de données « varlena », la
représentation sur disque de deux images de données égales peuvent ne pas être identiques
bit à bit, à cause des incohérences lors de l'application de la compression TOAST sur les
données en entrée. Dans les règles, quand une fonction equalimage d'une classe d'opérateur
retourne true, on peut présumer sans se tromper que la fonction C datum_image_eq()
correspondra avec la fonction order de la classe d'opérateur (sous réserve que le même
identifiant de collation soit passé aux fonctions equalimage et order).

Le code du moteur est fondamentalement incapable de déduire quoi que ce soit au

sujet du statut « l'égalité implique l'égalité d'image » d'une classe d'opérateur incluse dans une
famille de types de données multiples en se basant sur les détails d'autres classes d'opérateur
de la même famille. Aussi, il n'est pas pertinent pour une famille d'opérateurs d'inscrire une
fonction equalimage inter-type, et essayer déclenchera une error. En effet, le statut de «
l'égalité implique l'égalité d'image » ne dépend pas juste de la sémantique de l'ordre/égalité,
qui est plus ou moins définie au niveau de la famille d'opérateur. En général, les sémantiques
d'un type particulier de données doivent être considérées séparément.

La convention suivie par les classes d'opérateur incluses avec la distribution principale
PostgreSQL est d'inscrire une fonction générique equalimage. La plupart des classes
d'opérateur inscrivent btequalimage(), qui indique que le dédoublonnage est sécurisé sans
conditions. Les classes d'opérateur pour les types de données collationnés comme text
inscrivent btvarstrequalimage(), qui indique que le dédoublonnage est sécurisé avec les
collations déterministes. La bonne pratique pour une extension tierce est d'inscrire leur propre
fonction personnalisée pour garder le contrôle.

12
 e. Options :
En option, une famille d'opérateur B-tree peut fournir des fonctions de support des
options (« options spécifiques à la classe d'opérateur »), enregistrées sous le numéro 5 des
fonctions de support. Ces fonctions définissent un ensemble de paramètres visibles à
l'utilisateur et contrôlant le comportement de la classe d'opérateur.

Une fonction de support options doit avoir cette signature : options (relopts
local_relopts*) return void

La fonction se voit fournie un pointeur vers une structure local_relopts qui doit être
remplie avec un ensemble d'options spécifiques à une classe d'opérateur. Les options sont
accessibles à partir des autres fonctions de support en utilisant les macros
PG_HAS_OPCLASS_OPTIONS () et PG_GET_OPCLASS_OPTIONS ().

Actuellement, aucune classe d'opérateur B-Tree n'a de fonction de support options. B-

tree n'autorise pas une représentation flexible des clés comme GiST, SP-GiST, GIN et BRIN
le font. Donc, options n'a probablement pas beaucoup d'intérêt pour la méthode d'accès aux
index B-tree actuellement. Néanmoins, cette fonction de support a été ajouté au B-tree par
cohérence, et trouvera probablement son utilité lors des prochaines évolutions du B-tree dans
PostgreSQL.

IV- AVANTAGES ET DOMAINES D’APPLICATION DES B-Trees :

1. Avantages :

Un B-arbre (ou B-tree, en Anglais) est une structure de données/ méthodes qui permet
la localisation rapide d’un fichier (archives ou des clés), en particulier dans une base de
données. Il réduit le nombre de fois qu'un utilisateur a besoin d'accéder à la mémoire où les
données sont enregistrées. Les B-trees proviennent des arbres de recherche, que chaque clé
appartenant au sous-arbre gauche du nœud, est d'une valeur inférieure à chacune des
touches appartenant aux sous-arbres à la main droite ; De plus, leur structure assure l’équilibre
: pour chaque nœud, les hauteurs des sous-arbres droit et gauche diffèrent de plus d'une unité.
Ceci est l'avantage principal du B-Tree, et vous permet d'insérer, de supprimer et de temps de
recherche dépréciée logarithmiquement.

Les B-arbres apportent de solides avantages en termes de rapidité et d'efficacité par

rapport à d'autres mises en œuvre lorsque la plupart des nœuds sont dans le stockage

13
secondaire, comme un disque dur. En maximisant le nombre de nœuds enfants pour chaque
nœud, la hauteur de l'arbre est réduite, l'opération d'équilibrage est nécessaire moins souvent
et donc l'augmentation de l'efficacité. En général, ce nombre est réglé de telle sorte que
chaque nœud occupe tout un groupe de secteurs : ainsi, étant donné que les opérations de
bas niveau pour accéder au disque de cluster, il réduit au minimum le nombre d'accès à elle.
Ils offrent d'excellentes performances par rapport aux deux opérations de recherche et ceux
de rénovation, car les deux peuvent être faites avec la complexité logarithmique et par
l'utilisation des procédures très simples. Sur eux, il est également possible d'effectuer un
traitement séquentiel d'archivage primaire sans qu'il soit nécessaire de le soumettre à une
réorganisation.

2. Domaines d’applications :

Ils sont souvent utilisés dans le cadre de base de données, car ils permettent d'accéder
à des nœuds d'une manière efficace à la fois dans le cas où ils sont disponibles dans la
mémoire principale (via une cachette), Qu'ils ne sont présents que sur la mémoire de masse.

14
V-EXEMPLES :
1-L’implementation d’un B-tree en C++ :

2- Explication du bout de code :

Ce bout de code definit une structure generique de nœud pour une arborescence B+ où
chaque nœud contient une table de clés de taille l et un tableau de branches de tailles l+1.
La valeur retournée est simplement la définition de cette structure.

CONCLUSION

15
BIBLIOGRAPHIE ET WEBOGRAPHIE
 http://boowiki.info
 http://docs.postgresql.fr
 http://use-the-index-luke.com
 http://fr.wikipedia.org
 Présentation de B-Tree – Part 1 – StackLima

16