Notion sur les arbres binaires

Soit l’arbre binaire suivant : (figure 1)

1) Notion de chemin, ancêtre, frère et fils

● Notion de chemin
Le chemin a la racine d’un nœud est la listes des nœuds qu’ils faut parcourir depuis la
racine jusqu’à ce nœud

Ici, sur la figure 1 le chemin a la racine de 8 est : 1-2-5-8

● Notion d’ancêtre
Les ancêtres d’un nœud sont les nœuds se trouvant sur le chemin unique entre ce nœud et la racine.
Dans la figure 1 ; les ancêtres de 8 sont 1, 2, 5

● Notion de frère
Dans les arbres binaires, deux éléments sont dit frères, lorsqu’il sont issus d’un même père. Ici sur
la figure 1, les frères sont : 7 & 8(parent : 5) ; 4 & 5(parent : 2) ; 2 & 3(parent : 1)

2) Notion de feuille, nœud et hauteur

● Notion de feuille
Une feuille est un élément qui n’a pas de fils . Sur notre figure(figure 1) les 7, 8, 9 n’ont pas de fils
donc ce sont les feuilles.

● Notion de nœud
 ● Notion d’hauteur
La hauteur d’un nœud est la longueur du plus long chemin partant de ce nœud et aboutissant à une
feuille. Ici la hauteur(1) = 3 ; hauteur(7) = hauteur(8) = hauteur(9) = 0

La hauteur d’un arbre est la hauteur de sa racine. Ou encore d’un arbre est la plus grande
profondeur d’une feuille de l’arbre. Dans la figure 1, la hauteur de l’arbre est 3

3) Notion de racine et de degré d’un arbre

● Notion de racine
La racine de l’arbre est l’unique nœud ne possédant pas de parent. Dans la figure 1, la racine est 1

● Notion de degré
Le degré d’un arbre est le degré maximum de ses nœuds. Dans la figure ci-dessus,
degré(arbre) = 2

4) Notion d’enfant de gauche, enfant de droite et parent

● Notion d’enfant de gauche
Un enfant de gauche d’un arbre binaire est la racine de son sous-arbre gauche. Dans la figure 1,
l’enfant de gauche est 2

● Notion d’enfant de droite

Un enfant de droite d’un arbre binaire est la racine de son sous-arbre droite. Dans la figure
1, l’enfant de droite est 3

● Notion de parent
Element dont sont issus les fils

5) Mesure dur les arbres binaires : la taille d’un arbre binaire

La taille d'un arbre est le nombre total de nœuds qui le compose. Dans la figure 1 ci-dessus,
taille(arbre) = 9
Structure de creation d’un arbre binaire

Enregistrement nœud {
contenu : Entier;
gauche : Noeud;
droite : Noeud;
}

Les arbres bianires de recherche

Un arbre binaire de recherche est une structure de donn ́ee qui permet de representer un ensemble
de valeurs si l’on dispose d’une relation d’ordre sur ces valeurs. Les operations caracteristiques
sont l’insertion, la suppression et la recherche d’une valeur.

1) Definition

Un arbre binaire de recherche (abrege ABR) est un arbre binaire verifiant la propriete
suivante : soient x et y deux noeuds de l’arbre :
• Si y est un noeud du sous-arbre gauche de x alors cle(y) ≤ cle(x)
• Si y est un noeud du sous-arbre droit de x alors cle(y) ≥ cle(x)

Remarque:

Généralement, les valeurs dans un ABR sont uniques; on n’admet pas de répétition de valeur pour
éviter les confusion . Mais si jamais ceci arrive : par exemple si un arbre contient deux fois la valeur
4, par convention, la deuxième valeur est stockée dans le sous-arbre droit ayant pour racine 4.

2) Rechercher un element dans un arbre binaire de recherche

Cette fonction permet de rechercher un élément x dans un ABR et retourner un booléen. Pour
les ABR, les éléments sont stockés de façon à respecter une relation d’ordre, cela rend la
recherche plus beaucoup plus efficace que pour les arbre binaires quelconques.
 Fonction Recherche_rec (A: noeu, x: entier) : booleen
Début
si (estvide(A)) alors
retourner (faux)
sinon
si (A.contenu = x) alors
retourner (vrai)
sinon
si (A.contenu < x)
retourner (Recherche_rec (A.droite, x))
sinon
retourner( Recherche_rec (A.gauche, x))
Finsi
Finsi
Finsi
Fin

3) Recherche d’un élément dans un ABR (version itérative)

Dans un ABR, on sait de façon précise s’il faut continuer la recherche à gauche ou à droite
pour chaque nœud exploré, alors il est possible d’écrire une version itérativede recherche
dans un ABR

Fonction Recherche_iter (A: noeud, x: entier) :

booleen
Début
Tantque((!estvide(A)) et (x <> Racine (A)))faire
si (A.contenu < x) alors
A ← A.droite;
sinon
A ← A.gauche;
Finsi
Fintantque
si (estvide(A)) alors
retourner (faux);
sinon
retourner (vrai);
Finsi
4) Fin
Insertion d’un élément dans un ABR
Pour insérer un nouvel élément dans un ABR il faut d’abord repérer sa place dans l’arbre, il faut
donc le comparer aux éléments déjà existants dans l’ABR. Enfin l’insérer comme fils du dernier
nœud visité.

Procédure Inserer_rec(var A: noeud, e: entier)

Var P: nœud;
Début
si (estvide(A)) alors
nouveau(A);
^A.contenu ← e;
^A.droite ← Nil;
^A.gauche ← Nil ;
Liberer(A) ;
sinon
si (A.contenu > e) alors
Inserer_rec( A.droite, e);
sinon
Inserer_rec( A.gauche, e);
Finsi
Finsi
fin

5) Suppression d’un élément d’un ABR

La suppression dans un ABR est assez compliqué, c’est pour cela que nous allons
détailler tous les cas possibles.
Pour supprimer un nœud dans un ABR, plusieurs cas de figure peuvent se présenter. Il est
toutefois nécessaire d’obtenir un ABR à l’issue de la suppression.

D’abord il faut chercher l’élément à supprimer, une fois trouvé on se trouve dans l’une
des situations suivantes, soit « n » le nœud à supprimer:

● 1er cas : n est une feuille : on la supprime et on la remplace par Nil.

● 2eme cas : i est un nœud qui a un seul fils : on supprime i et on le remplace par
ce fils.
● 3eme cas : i est un nœud qui a deux fils : on supprime i et on le remplace par
l’élément minimum se trouvant dans son sous arbre droit (le nœud le plus à
gauche du sous arbre droit)ou par l’élément maximum se trouvant dans son
sous arbre gauche (le nœud le plus à droite du sous arbre gauche).

Pour le 3ème cas nous avons besoin d’abord de déterminer le plus proche prédécesseur (maximum
du SAG du nœud n) et le plus proche successeur (minimum du SAD du nœud n).

Fonction maximum( A: noeud):noeud Fonction minimum( A: noeud):noeud

Début Début
si (A.droite <> Nil) alors si (A.gauche <> Nil) alors
retourner(maximum(A.droite)); retourner(minimum(A.gauche));
sinon sinon
retourner(A); retourner(A);
 La procedure de suppression est la suivante :

Procédure supprimer_rec(var A: noeud, x: entier)

Var p,Q : noeud
Début
Si (A=Nil) alors
écrire(x, ’’ est introuvable’’);
Sinon
si(A.contenu = x) alors // on distingue 3 cas
si (feuille (A)) alors
libérer (A); // 1er cas
sinon
si ((A.gauche != Nil) et (A.droite = Nil)) alors
Q ← A;
A ← A.gauche;
libérer (Q);
sinon
si ((A.gauche = Nil) et (A.droite != Nil)) alors
Q←A;
A ← A.droite;
libérer(Q);
sinon
si ((A.gauche != Nil) et (A.droite != Nil)) alors
P← minimum(A.droite); // ou P← maximum(A.gauche);
A.contenu ← P.contenu;
supprimer_rec(P, P.contenu);
Finsi // 3 eme cas
finsi
Finsi
sinon
si(A.contenu < x) alors
supprimer_rec(A.droite, x);
sinon
supprimer_rec (A.gauche, x);
finsi
finsi
Finsi
Fin

Parcours sur les arbres binaires

 Parcourir un arbre, c’est ordonner la liste des noeuds et feuilles de celui-ci en vue d’effectuer un
certain traitement (par exemple imprimer la liste des étiquettes de cet arbre).

1) Parcour en largeur
Le parcours en largeur consiste à parcourir l'arbre niveau par niveau. Les nœuds de niveau 0 sont
sont d'abord parcourus puis les nœuds de niveau 1 et ainsi de suite. Dans chaque niveau, les nœuds
sont parcourus de la gauche vers la droite. Le parcours en largeur de l'arbre ci-dessous parcours les
nœuds dans l'ordre
11 | 8 | 14 | 5 | 10 | 13 | 15

Algorithme de parcour en largeur

Nous allons utiliser une file pour le faire

Procedure parcoursLageur(racine: nœud)

f1: file;
n1: nœud;

Debut

Intialisation(f1);
enfiler(f1, racine);

tantque(!estvide(f1))faire
n1 ← valeurdebut(f1);
ecrire(n1.contenu);
 2) Parcour en profondeur
Des parcours en profondeur explorent l’arbre branche par branche où on descend le plus
profondément possible dans l’arbre puis une fois qu’une feuille a été atteinte, on remonte pour
explorer les autres branches en commençant par la branche ‘’la plus basse’’ parmi celles non encore
parcourues.

a) Parcour prefixe ou preordre

Le parcours préordre de l’arbre R (s’il n’est pas vide) consiste à visiter le nœud racine (R) ensuite
parcourir récursivement en préordre les sous arbres T1 (sous arbre gauche) puis T2 (sous arbre
droit) ce qui donne : [R, T1, T2] ou (RGD)
Le resultat du parcour en profondeur preffxe det cet arbre est : A | B | D | H | I | E | C | F | G

Il s’agit de parcourir la racine d’abord, ensuite explorer le sous-arbre gauche, et finalement explorer
le sous-arbre droit.
La procédure (récursive) qui affiche les valeurs en parcours préfixe d’un arbre A est:

Procédure Préfixe(A: noeud)

Début
Si (!estvide(A)) alors
Ecrire (Racine (A)) ;
Préfixe(FilsGauche (A)) ;
Préfixe(FilsDroite(A)) ;
Sinon
Ecrire(‘’L’abre est vide’’) ;

Finsi
Fin

Ici FilsGauche() et FilsDroite() sont des fonctions qui retourne respectivement le fils gauche et le
fils droit de l’arbre

Fonction FilsGauche(abre: nœud): noeud

Début
Si (!estvide(A)) alors
retourner abre.gauche ;
sinon
Ecrire(‘’L’abre est vide’’) ;
Finsi
Fin

b) Parcour infixe ou inordre

Le parcours inordre de l’arbre R (s’il n’est pas vide) consiste à parcourir récursivement en inordre
les sous arbres T1 (sous arbre gauche) puis visiter le nœud racine (R) ensuite parcourir
récursivement en inordre T2 (sous arbre droit) ce qui donne : [T1, R, T2] ou (GRD)

Le resultat du parcour en profondeur preffxe det cet arbre est :

H|D|I|B|E|A|F|C|G
l s’agit d’explorer le sous-arbre gauche, visiter la racine et finalement explorer le sous-arbre droit.
La procédure (récursive) qui affiche les valeurs en parcours infixe d’un arbre A est:

Procédure Infixe(A: noeud)

Début
Si (!estvide(A)) alors
Infixe (FilsGauche (A));
Ecrire (Racine (A));
Infixe (FilsDroite(A));
Sinon
Ecrire(‘’L’abre est vide’’) ;

Finsi
Fin

c) Parcour postfixe

Le parcours postordre de l’arbre R (s’il n’est pas vide) consiste à parcourir récursivement en inordre
les sous arbres T1 (sous arbre gauche) ensuite parcourir récursivement en inordre T2 (sous arbre
droit) puis visiter le nœud racine (R) ce qui donne : [T1, T2, R] ou (GDR)

Le resultat du parcour en profondeur preffxe det cet arbre est :

H|I|D|E|B|F|G|C|A

Il s’agit d’explorer le sous-arbre gauche, explorer le

sous-arbre droit et finalement visiter la racine.
La procédure (récursive) qui affiche les valeurs en parcours postfixe d’un arbre A est:

Procédure Postfixe(A: noeud)

Début
Si(!estvide(A)) alors
Postfixe(FilsGauche (A));
Postfixe(FilsDroite(A));
Ecrire(Racine (A));
Sinon
Ecrire(‘’L’abre est vide’’);

Finsi
Fin