Arbre binaire

En informatique, un arbre binaire est une structure de donnes qui peut se reprsenter sous la forme d'une
hirarchie dont chaque lment est appel nud, le nud initial tant appel racine. Dans un arbre binaire,
chaque lment possde au plus deux lments fils au niveau infrieur, habituellement appels gauche et
droit. Du point de vue de ces lments fils, l'lment dont ils sont issus au niveau suprieur est appel pre.

Au niveau le plus lev il y a donc un nud racine. Au niveau directement infrieur, il y a au plus deux
nuds fils. En continuant descendre aux niveaux infrieurs, on peut en avoir quatre, puis huit, seize, etc.
c'est--dire la suite des puissances de deux. Un nud n'ayant aucun fils est appel feuille. Le nombre de
niveaux total, autrement dit la distance entre la feuille la plus loigne et la racine, est appel hauteur de
l'arbre.

Le niveau d'un nud est appel profondeur.

Les arbres binaires peuvent notamment tre utiliss en tant qu'arbre binaire de recherche ou en tant que tas
binaire.

Un exemple simple d'arbre binaire

Sommaire
1 Dfinition dans la thorie des graphes
2 Types d'arbre binaire
3 Mthode pour stocker des arbres binaires
4 Mthode d'itration des arbres binaires
o 4.1 Parcours prfixe, infixe et postfixe
4.1.1 Parcours prfixe
4.1.2 Parcours postfixe ou suffixe
4.1.3 Parcours infixe
o 4.2 Parcours en profondeur
o 4.3 Parcours en largeur
5 Transformation d'un arbre quelconque en un arbre binaire
6 Voir aussi
o 6.1 Algorithmes utilisant des arbres binaires
o 6.2 Arbres binaires particuliers
o 6.3 Autres types d'arbres
7 Notes et rfrences

Dfinition dans la thorie des graphes

La thorie des graphes utilise la dfinition suivante : un arbre binaire est un graphe connexe acyclique, tel
que le degr de chaque nud (ou vertex) soit au plus 3.
La racine d'un arbre binaire est le nud d'un graphe de degr maximum 2. Avec une racine ainsi choisie,
chaque nud aura un unique parent dfini et deux fils ; toutefois, ces informations sont insuffisantes pour
distinguer un fils droit d'un fils gauche. Si nous ngligeons cette condition de connexit, et qu'il y a de
multiples lments connects, on appellera cette structure une fort.

Types d'arbre binaire

Un arbre binaire (ou binaire-unaire) est un arbre avec racine dans lequel chaque nud a au plus
deux fils.

Un arbre binaire entier est un arbre dont tous les nuds possdent zro ou deux fils.

Un arbre binaire parfait est un arbre binaire entier dans lequel toutes les feuilles (nuds n'ayant
aucun fils) sont la mme distance de la racine.

L'arbre binaire parfait est parfois nomm arbre binaire complet. Cependant certains dfinissent un arbre
binaire complet comme tant un arbre binaire entier dans lequel les feuilles ont pour profondeur n ou n-1
pour un n donn.

Mthode pour stocker des arbres binaires

Les arbres binaires peuvent tre construits partir de primitives d'un langage de programmation de
diffrentes manires. Dans un langage avec structures et pointeurs (ou rfrences), les arbres binaires
peuvent tre conus en ayant une structure trois nuds qui contiennent quelques donnes et pointeurs vers
son fils droit et son fils gauche. L'ordre que cela impose aux nuds enfants est parfois utile, en particulier
pour les parcours infixes. Parfois, il contient galement un pointeur vers son unique parent. Si un nud
possde moins de deux fils, l'un des deux pointeurs peut tre affect de la valeur spciale nulle ; il peut
galement pointer vers un nud sentinelle.

Les arbres binaires peuvent aussi tre rangs dans des tableaux, et si l'arbre est un arbre binaire complet,
cette mthode ne gaspille pas de place, et la donne structure rsultante est appele un tas. Dans cet
arrangement compact, un nud a un indice i, et (le tableau tant bas sur des zros) ses fils se trouvent aux
indices 2i+1 et 2i+2, tandis que son pre se trouve (s'il existe) l'indice floor((i-1)/2). Cette mthode permet
de bnficier d'un encombrement moindre, et d'un meilleur rfrenage, en particulier durant un parcours
prfixe. Toutefois, elle requiert une mmoire contige, elle est coteuse s'il s'agit d'tendre l'arbre et l'espace
perdu (dans le cas d'un arbre binaire non complet) est proportionnel 2h - n pour un arbre de profondeur h
avec n nuds.

Dans les langages union tiquete comme ML, un nud est souvent une union tague de deux types de
nud, l'un tant un triplet contenant des donnes et ses fils droits et gauches, et l'autre un nud vide, qui ne
contient ni donne ni fonction, ressemblant la valeur nulle des langages avec pointeurs.

Mthode d'itration des arbres binaires

Souvent, il est souhaitable de visiter chacun des nuds dans un arbre et d'y examiner la valeur. Il existe
plusieurs ordres dans lesquels les nuds peuvent tre visits, et chacun a des proprits utiles qui sont
exploites par les algorithmes bass sur les arbres binaires.
Parcours prfixe, infixe et postfixe

(parfois appels prordre, inordre et postordre)

Soit une structure Arbre dont la racine est A et une rfrence gauche et droite ses deux fils. Nous
pouvons crire les fonctions suivantes :

Parcours prfixe

visiterPrfixe(Arbre A) :
visiter(A)
Si nonVide(gauche(A))
visiterPrfixe(gauche(A))
Si nonVide(droite(A))
visiterPrfixe(droite(A))

Ceci affiche les valeurs de l'arbre en ordre prfixe. Dans cet ordre, chaque nud est visit ainsi que chacun
de ses fils.

Parcours postfixe ou suffixe

visiterPostfixe(Arbre A) :
Si nonVide(gauche(A))
visiterPostfixe(gauche(A))
Si nonVide(droite(A))
visiterPostfixe(droite(A))
visiter(A)

Dans un parcours postfixe ou suffixe, on affiche chaque nud aprs avoir affich chacun de ses fils.

Parcours infixe

visiterInfixe(Arbre A) :
Si nonVide(gauche(A))
visiterInfixe(gauche(A))
visiter(A)
Si nonVide(droite(A))
visiterInfixe(droite(A))

Un parcours infixe, comme ci-dessus, visite chaque nud entre les nuds de son sous-arbre de gauche et les
nuds de son sous-arbre de droite. C'est une manire assez commune de parcourir un arbre binaire de
recherche, car il donne les valeurs dans l'ordre croissant.

Pour comprendre pourquoi cela est le cas, si n est un nud dans un arbre binaire de recherche, alors tous les
lments dans le sous-arbre de gauche du nud n seront infrieurs n et ceux dans le sous-arbre de droite
seront suprieurs ou gaux n. Ainsi, si nous visitons le sous-arbre de gauche dans l'ordre, de manire
rcursive, puis que nous visitons n, et que nous visitons le sous-arbre de droite, nous aurons visit l'ensemble
du sous-arbre enracin en n dans l'ordre.
 Dans cet arbre binaire,

Rendu du parcours infixe : 4, 2, 7, 5,

8, 1, 3, 9, 6
Rendu du parcours postfixe : 4, 7, 8,
5, 2, 9, 6, 3, 1
Rendu du parcours prfixe : 1, 2, 4,
5, 7, 8, 3, 6, 9

Nous pouvons effectuer ces parcours avec un langage fonctionnel comme Haskell avec le code suivant :

data Tree a = Leaf | Node(a, Tree a, Tree a)

preorder Leaf = []
preorder (Node (x, left,right)) = [x] ++ (preorder left) ++ (preorder right)

postorder Leaf = []
postorder (Node (x, left,right)) = (postorder left) ++ (postorder right) ++ [x]

inorder Leaf = []
inorder (Node (x, left,right)) = (inorder left) ++ [x] ++ (inorder right)

Tous ces algorithmes rcursifs utilisent une pile mmoire proportionnelle la profondeur des arbres. Si nous
rajoutons dans chaque nud une rfrence son parent, alors nous pouvons implmenter tous ces parcours
en utilisant des espaces mmoires uniquement constants et un algorithme itratif. La rfrence au parent
occupe cependant beaucoup d'espace ; elle n'est rellement utile que si elle est par ailleurs ncessite ou si la
pile mmoire est particulirement limite. Voici par exemple, l'algorithme itratif pour le parcours infixe :

VisiterInfixeIteratif(racine)
precedent := null
actuel := racine
suivant := null

Tant que (actuel != null) Faire

Si (precedent == pere(actuel)) Alors
precedent := actuel
suivant := gauche(actuel)
FinSi
Si (suivant == null OU precedent == gauche(actuel)) Alors
Visiter(actuel)
precedent := actuel
suivant := droite(actuel)
FinSi
Si (suivant == null OU precedent == droite(actuel)) Alors
precedent := actuel
suivant := pere(actuel)
FinSi
actuel := suivant
FinTantQue

Parcours en profondeur
Avec ce parcours, nous tentons toujours de visiter le nud le plus loign de la racine que nous pouvons,
la condition qu'il soit le fils d'un nud que nous avons dj visit. l'oppos des parcours en profondeur sur
les graphes, il n'est pas ncessaire de connatre les nuds dj visits, car un arbre ne contient pas de cycles.
Les parcours prfixe, infixe et postfixe sont des cas particuliers de ce type de parcours.

Pour effectuer ce parcours, il est ncessaire de conserver une liste des lments en attente de traitement.
Dans le cas du parcours en profondeur, il faut que cette liste ait une structure de pile (de type LIFO, Last In,
First Out autrement dit: dernier entr, premier sorti ). Dans cette implmentation, on choisira galement
d'ajouter les fils d'un nud de droite gauche.

ParcoursProfondeur(Arbre A) {
S = Pilevide
ajouter(Racine(A), S)
Tant que (S != Pilevide) {
nud = premier(S)
retirer(S)
Visiter(nud) //On choisit de faire une opration
Si (droite(nud) != null) Alors
ajouter(droite(nud), S)
Si (gauche(nud) != null) Alors
ajouter(gauche(nud), S)
}
}

Parcours en largeur

Contrairement au prcdent, ce parcours essaie toujours de visiter le nud le plus proche de la racine qui n'a
pas dj t visit. En suivant ce parcours, on va d'abord visiter la racine, puis les nuds la profondeur 1,
puis 2, etc. D'o le nom parcours en largeur.

L'implmentation est quasiment identique celle du parcours en profondeur ce dtail prs qu'on doit cette
fois utiliser une structure de file d'attente (de type FIFO, First in, first out autrement dit premier entr,
premier sorti ), ce qui induit que l'ordre de sortie n'est pas le mme (i.e. on permute gauche et droite dans
notre traitement).

ParcoursLargeur(Arbre A) {
f = FileVide
enfiler(Racine(A), f)
Tant que (f != FileVide) {
nud = defiler(f)
Visiter(nud) //On choisit de faire une opration
Si (gauche(nud) != null) Alors
enfiler(gauche(nud), f)
Si (droite(nud) != null) Alors
enfiler(droite(nud), f)
}
}

Transformation d'un arbre quelconque en un arbre binaire

Il existe une injection entre les arbres tris gnraux et les arbres binaires, qui est spcialement utilise par
Lisp pour reprsenter les arbres tris gnraux en tant qu'arbres binaires. Chaque nud N dans l'arbre tri
correspond au nud N' dans l'arbre binaire ; le fils gauche de N' est le nud correspondant au premier fils de
N, et le fils droit de N' est le nud correspondant au prochain frre de N - qui est le nud suivant dans
l'ordre parmi les enfants du pre de N.

Une manire de se reprsenter ceci est de penser que chaque fils d'un nud est dans une liste lie,
mutuellement lis par leurs champs droits, et que le nud possde seulement un pointeur vers le dbut de la
liste, jusqu' son champ gauche.
Par exemple, dans l'arbre de gauche, A a 6 fils : {B, C, D, E, F, G}. Il peut tre converti en arbre binaire
(comme celui de droite).

Cet arbre binaire peut tre considr comme l'arbre original inclin en longueur, avec les cts noirs de
gauche reprsentant les premiers fils et les cts bleus de droite reprsentant ses prochains frres. La part de
l'arbre de gauche pourrait tre code en Lisp comme ceci :

(((M N) H I) C D ((O) (P)) F (L))

qui pourrait tre implmente en mmoire comme l'arbre binaire de droite, sans les lettres de ce nud qui
ont un fils gauche.

Voir aussi
Sur les autres projets Wikimedia :

Arbre binaire, sur Wikiversity

Nombre de Strahler

Algorithmes utilisant des arbres binaires

Codage de Huffman
Algorithme des nuds chapeaux

Arbres binaires particuliers

Arbre binaire de recherche

Arbre AVL
Arbre bicolore (arbre rouge-noir)
Arbre cousu
Arbre binaire de recherche

Exemple reprsentant un arbre binaire de recherche

En informatique, un arbre binaire de recherche (ABR) est un arbre binaire dans lequel chaque nud
possde une cl, telle que chaque nud du sous-arbre gauche ait une cl infrieure ou gale celle du nud
considr, et que chaque nud du sous-arbre droit possde une cl suprieure ou gale celle-ci selon la
mise en uvre de l'ABR, on pourra interdire ou non des cls de valeur gale. Les nuds que l'on ajoute
deviennent des feuilles de l'arbre.

Oprations
Recherche

La recherche dans un arbre binaire d'un nud ayant une cl particulire est un procd rcursif. On
commence par examiner la racine. Si sa cl est la cl recherche, l'algorithme termine et renvoie la racine. Si
elle est strictement infrieure, alors elle est dans le sous-arbre gauche, sur lequel on effectue alors
rcursivement la recherche. De mme si la cl de la racine est strictement suprieure la cl recherche la
recherche continue sur le sous-arbre droit. Si on atteint une feuille dont la cl n'est pas celle recherche, on
sait alors que la cl recherche n'appartient aucun nud. On peut la comparer avec la recherche par
dichotomie qui procde peu prs de la mme manire sauf qu'elle accde directement chaque lment
d'un tableau au lieu de suivre des liens.

Cette opration requiert un temps en O(log(n)) dans le cas moyen, mais O(n) dans le cas critique o l'arbre
est compltement dsquilibr et ressemble une liste chane.

Insertion

L'insertion d'un nud commence par une recherche : on cherche la cl du nud insrer ; lorsqu'on arrive
une feuille, on ajoute le nud comme fils de la feuille en comparant sa cl celle de la feuille : si elle est
infrieure, le nouveau nud sera gauche ; sinon il sera droite.

La complexit est la mme que pour la recherche : O(log n) dans le cas moyen et O(n) dans le cas critique.

Suppression

Plusieurs cas sont considrer, une fois que le nud supprimer a t trouv partir de sa cl :

Suppression d'une feuille : Il suffit de l'enlever de l'arbre vu qu'elle n'a pas de fils.
Suppression d'un nud avec un enfant : Il faut l'enlever de l'arbre en le remplaant par son fils.
 Suppression d'un nud avec deux enfants : Supposons que le nud supprimer soit appel N (le nud de
valeur 7 dans le graphique ci-dessous). On change le nud N avec son successeur le plus proche (le nud
le plus gauche du sous-arbre droit - ci-dessous, le nud de valeur 9) ou son plus proche prdcesseur (le
nud le plus droite du sous-arbre gauche - ci-dessous, le nud de valeur 6). Cela permet de garder une
structure d'arbre binaire de recherche. Puis on applique nouveau la procdure de suppression N, qui est
maintenant une feuille ou un nud avec un seul fils.

Pour une implmentation efficace, il est dconseill d'utiliser uniquement le successeur ou le prdcesseur
car cela contribue dsquilibrer l'arbre.

Dans tous les cas cette opration requiert de parcourir l'arbre de la racine jusqu' une feuille : le temps
d'excution est donc proportionnel la profondeur de l'arbre qui vaut n dans le pire des cas, d'o une
complexit maximale en O(n).

Parcours ordonn

On peut facilement rcuprer les lments d'un arbre binaire de recherche dans l'ordre de leurs cls en
parcourant rcursivement le sous-arbre gauche, puis en ajoutant la racine, puis en parcourant rcursivement
le sous-arbre droit. On peut videmment le faire dans l'ordre inverse en commenant par le sous-arbre droit.

Le parcours de l'arbre se fait en O(n), puisqu'il doit passer par chaque nud.

Tri

On peut ds lors implmenter un algorithme de tri simple mais peu efficace, en insrant toutes les cls que
l'on veut trier dans un nouvel arbre binaire de recherche, puis en parcourant de manire ordonne cet arbre
comme ci-dessus.

Le pire temps d'excution est en O(n), obtenu lorsque les cls sont dj ordonnes : on obtient alors une
liste chane. Par exemple, si on donne dans cet ordre les cls 1, 2, 3, 4, 5, on obtient l'arbre (Vide, 1, (Vide,
2, (Vide, 3, (Vide, 4, (Vide, 5, Vide))))). Il y a de nombreuses faons d'viter ce problme, la plus commune
tant l'arbre quilibr. On peut alors arriver un pire cas en O(n ln n).

Types d'arbres binaires de recherche

Il existe de nombreux types d'arbres binaires de recherche. Les arbres AVL et les arbres rouge-noir sont
deux types d'arbres quilibrs. Un arbre splay est un arbre binaire de recherche qui rapproche
automatiquement de la racine les lments utiliss frquemment. Dans un treap, chaque nud possde aussi
une priorit suprieure chacun de ses fils.