Chapitre III.

Structures arborescentes
-  Arbres binaires
-  Arbres binaires de recherche

Sources:
1- Cours les arbres binaires, Larbi. https://www.lri.fr/~fiorenzi/Teaching/AL/C4.pdf
2- Cours algoritmique, Anne Vilnat. http://www.limsi.fr/Individu/anne/coursAlgo
3- Arbres binaires de recherche, François Denis. http://pageperso.lif.univ-mrs.fr/~francois.denis/algoMPCI/chap1.pdf
4- https://developpement-informatique.com/article/177/supprimer-un-noeud-de-larbre-binaire-de-recherche

1. Arbres binaires

2
Chap III: Structures arborescentes

Arbres binaires
Une arborescence est utilisée :
§  Dans la vie de tous les jours : pour représenter des hiérarchies, des classifications,
des partitions,...
§  En informatique pour représenter des informations de ce type et aussi pour :
•  l’organisation interne des fichiers en mémoire
•  les modes de calcul d’une expression
•  l’organisation des données triées

§  Exemple de classification
Quelle logique?
•  du plus générique au plus spécifique
•  du plus ancien au plus récent
•  de la plus haute autorité à la moindre
•  du plus complexe au plus simple

© O.Lamouchi
3

Chap III: Structures arborescentes

Arbres binaires
§  Exemple d’expressions arithmétiques §  Terminologie

(x-(2*y))+((x+(y/z))*3)

© O.Lamouchi
4
Chap III: Structures arborescentes

Arbres binaires

§  Définition
•  Un arbre binaire c’est:
- soit un arbre vide
-  soit une racine avec deux sous-arbres binaires : fils gauche et fils droit

§  La hauteur
•  La hauteur d’un nœud est la longueur du plus long chemin de ce nœud aux
feuilles qui en dépendent plus 1.
•  La hauteur d’un arbre est la hauteur de sa Racine (L’arbre vide a une hauteur 0)

§  La profondeur (niveau)
•  La profondeur d’un nœud est le nombre de nœuds du chemin qui va de la racine
à ce nœud (La racine d’un arbre est à une profondeur 0).
•  La profondeur d’un nœud est égale à la profondeur de son père plus 1. (Si un
nœud est à une profondeur p, tous ses fils sont à une profondeur p+1).
© O.Lamouchi
5

Arbres binaires
Chap III: Structures arborescentes

Opérations sur les Arbres binaires

•  Les arbres binaires (AB) forment une structure de données qui peut être définie récursivement
de la manière suivante : un arbre binaire est:
- Soit vide,
-  Soit composé d’une racine portant une étiquette (clé) et d’une paire d’arbres binaires,
appelés fils gauche et droit.
@racine

TYPE NOEUD = STRUCTURE @fg

Info
@fd

Info : TYPE_INFO
Info Info
FG : *NŒUD @fg @fd @fg @fd

FD : *NŒUD
Info Info Info Info
@fg @fd @fg @fd @fg @fd @fg @fd
FIN STRUCTURE

TYPE ArbreBinaire = *NŒUD : : : :

© O.Lamouchi
6
 Arbres binaires
Chap III: Structures arborescentes

Opérations sur les Arbres binaires (suite)

•  Pour pouvoir manipuler des arbres de recherche, on doit donc disposer des fonctionnalités
suivantes :

•  Fonction vide(Arb:ArbreBinaire) retourne Booléen: Vrai si l’arbre binaire est vide, faux
sinon.

•  Fonction Info(Arb:ArbreBinaire) retourne Type_Info: Valeur enregistrée à la racine.

•  Fonction FilsGauche(Arb:ArbreBinaire) Retourne ArbreBinaire: Retourne l’arbre
binaire formé par le sous-arbre gauche. Erreur si l’arbre binaire est vide.

•  Fonction FilsDroit(Arb:ArbreBinaire) Retourne ArbreBinaire: Retourne l’arbre binaire

formé par le sous-arbre droit. Erreur si l’arbre binaire est vide.

•  Procedure AjoutGauche(Arb:ArbreBinaire,val:Type_Info): Ajout au premier fils gauche

vide.

•  Procedure AjoutDroit(Arb:ArbreBinaire,val:Type_Info) : Ajout de val au premier fils droit

vide.

•  Fonction CreerArbre(val:TypeInfo, fg:ArbreBinaire, fd:ArbreBinaire): Retourne la

racine de l’arbre binaire et l’ajout du sous-arbre gauche et le sous-arbre droite, s’ils existent.
© O.Lamouchi
7

Arbres binaires
Chap III: Structures arborescentes

Parcours d’un arbre binaire

•  Le parcours le plus simple à programmer est le parcours dit en profondeur d’abord.

•  Pour parcourir un arbre non vide a:

-  On parcourt récursivement son sous-arbre gauche,

-  puis son sous-arbre droit,
-  la racine de l’arbre pouvant être traitée au début, entre les deux parcours ou à la
fin. => Dans le premier cas, on dit que les nœuds sont traités dans un ordre
préfixe, dans le second cas, dans un ordre infixe et dans le troisième cas, selon
un ordre postfixe.

© O.Lamouchi
8
 Arbres binaires
Chap III: Structures arborescentes

Affichages: Ordre préfixe

Ordre préfixe (la racine d’abord): On affiche la racine, puis le
sous-arbre gauche, puis le sous-arbre droit.

=> Ce qui donne ici: 12, 1, 91, 67, 7, 82, 61

Source: 3

Procedure PaffichePrefixe(a:ArbreBinaire)
DEBUT
SI Vide(a)=FAUX Alors //Test d’arrêt

ECRIRE (Info(a)) //Traitement

PaffichePrefixe(FilsGauche(a)) //Appel récursif

PaffichePrefixe(FilsDroite(a)) //Appel récursif

FINSI
FIN
© O.Lamouchi
9

Arbres binaires
Chap III: Structures arborescentes

Affichages: Ordre postfixe

Ordre postfixe (la racine à la fin): On affiche le sous-arbre
gauche, puis le sous-arbre droit, puis la racine.

⇒  Ce qui donne ici: 91, 67, 1, 61, 82, 7, 12

Source: 3

Procedure PaffichePostfixe(a:ArbreBinaire)
DEBUT
SI Vide(a)=FAUX Alors //Test d’arrêt

PaffichePostfixe(FilsGauche(a)) //Appel récursif

PaffichePostfixe(FilsDroite(a)) //Appel récursif

ECRIRE (Info(a)) //Traitement

FINSI
FIN
© O.Lamouchi
10
 Arbres binaires
Chap III: Structures arborescentes

Affichages: Ordre infixe

Ordre infixe (la racine au milieu): On affiche le sous-arbre
gauche, puis la racine, puis le sous-arbre droit.

=> Ce qui donne ici: 91, 1, 67, 12, 7, 61, 82

Source: 3

Procedure PafficheInfixe(a:ArbreBinaire)
DEBUT
SI Vide(a)=FAUX Alors //Test d’arrêt

PafficheInfixe(FilsGauche(a)) //Appel récursif

ECRIRE (Info(a)) //Traitement

PafficheInfixe(FilsDroite(a)) //Appel récursif

FINSI
FIN
© O.Lamouchi
11

Arbres binaires
Chap III: Structures arborescentes

Recherche d’un élément

§  DFS : Depth-First Search ou recherche en profondeur d’abord
! Avec DFS, on n’a besoin
On cherche à la racine, si l’élément n’y est pas: d’aucun stockage en plus mais
o n p e u t s ’ a t t a rd e r t ro p
- On cherche dans le fils gauche
longtemps dans une branche.
- S’il n’est pas dans le fils gauche, on cherche dans le fils droit
=> La recherche s’arrête quand on a trouvé ou qu’il n’y a plus de
branches à explorer.
=> Un fonctionnement récursif
§  BFS : Breadth-First Search ou recherche en largeur
d’abord
! Avec BFS, on fonctionne
On cherche à la racine, si l’élément n’y est pas : par profondeur incrémentale
donc on évite le piège mais on
- On cherche dans les nœuds de profondeur 1 a besoin d’un stockage dont la
- S’il n’est pas dans à la profondeur 1, on cherche à la taille augmente à chaque
étape.
profondeur 2, …
=> Un fonctionnement itératif
© O.Lamouchi
12
 Arbres binaires
Chap III: Structures arborescentes

Recherche d’un élément: DFS

DFS : Depth-First Search ou recherche en profondeur d’abord

Exemples:
•  Chercher la valeur 4
-  Racine=1 => non •  Chercher la valeur 3
// passer au fils gauche -  Racine=1 => non
-  Racine=2 => non // passer au fils gauche
// passer au fils gauche -  Racine=2 => non
-  Racine =4 => Trouvé // passer au fils gauche
-  Racine =4 => non
-  Pas de fils
-  Pas de fils droite
// passer au fils droit
-  Racine=3 => Trouvé

! Si l’élément est dans le sous arbre droit de la racine, on va quand même explorer
tout le sous-arbre de gauche
© O.Lamouchi
13

Arbres binaires
Chap III: Structures arborescentes

Recherche d’un élément: BFS

BFS : Breadth-First Search ou recherche en largeur d’abord

On va avoir besoin d’une file FIFO (ou autre

Exemples 1:
structure équivalente) pour stocker les nœuds à
•  Chercher la valeur 3
explorer.
- File=[arbre (1)]
•  Au début, la file contient l’arbre principal
- Racine=1 => non
(racine)
//On défile l’arbre(1) et on enfile ses 2 sous-
•  Si la valeur n’est pas à la racine du premier arbres
arbre de la file - File= [sous-arbre gauche (1), sous-arbre
-  On supprime l’arbre de la file droit (1)
-  On ajoute ses deux sous-arbre en fin de file - Racine=2 => non
s’ils ne sont pas vides
//On défile la racine 2 et on enfile ses sous-
-  Et on explore l’arbre suivant, qui est le arbres
premier de la file
•  On s’arrête quand on a trouvé ou que la file est - File= [sous-arbre droite (1), sous-arbre
vide gauche (2)]
-  Racine =3 => Trouvé
© O.Lamouchi
14
 Arbres binaires
Chap III: Structures arborescentes

Recherche d’un élément: BFS

BFS : Breadth-First Search ou recherche en largeur d’abord

Exemple 2:
•  Chercher la valeur 4
- File=[arbre (1)]
- Racine=1 => non
//On défile l’arbre(1) et on enfile ses 2 sous-arbres
- File= [sous-arbre gauche (1), sous-arbre droit (1)
- Racine=2 => non
//On défile la racine 2 et on enfile ses sous-arbres

- File= [sous-arbre droite (1), sous-arbre gauche (2)]

-  Racine =3 => non
//On défile la racine 3 et on enfile ses sous-arbres
- File= [sous-arbre gauche (2), sous-arbre gauche (3), sous-arbre droit (3)]
- Racine=4 => Trouvé
© O.Lamouchi
15