Les arbres: Rappels

F. OUAZAR LOUNNACI
Définitions
 Un arbre est une structure de données arborescente récursive.
 Cette structure de données (Dynamique) représente un
ensemble de valeurs organisées hiérarchiquement (non linéaire)
 Chaque valeur est stockée dans un nœud
 Les nœuds sont relié entre eux par des arêtes qui représentent la
relation père/fils
 Un nœud peut avoir zéro ou plusieurs successeurs (appelés
descendants ou fils) et au maximum un prédécesseur (appelé
ascendant ou père).
 La racine de l’arbre ne possède pas de prédécesseur.
 Les nœuds feuilles (ou nœuds terminaux) n’ont pas de
successeurs.
A : racine de l’arbre
B, E, F, G : feuilles ou
nœuds terminaux
C, D : nœuds internes
C, B, D sont les
descendants de A ou fils
de A
A est l’ascendant (père)
de B, C et D
E, F sont les descendants
(ou fils) de C
C est l’ascendant (ou
père) de E et F
Degré d’un nœud
 Le degré d’un nœud représente le nombre de successeurs de
ce nœud.
 Le degré d’un arbre est égal au maximum des degrés de ses
nœuds.
 D’une manière générale, un arbre de degré n est appelé
arbre n-aire.

Niveau d’un nœud

 La hiérarchie est représentée par des niveaux dans l’arbre, la
racine étant le nœud de niveau 0.
 Si N2 est un successeur de N1, niveau(N2) = niveau(N1)+1.
 La profondeur d’un arbre
 La profondeur (hauteur) d’un arbre est la longueur de la branche la
plus longue de l’arbre (de la racine jusqu’à un nœud feuille)
Le nœud A représente la racine, B et
C sont des nœuds internes, D, E, F,
G sont des feuilles.
degré (A) = 2, degré (B) = 3,
degré(C) =1, degré (D) = degré(E)
= degré(F) = degré(G) =0.
Il s’agit d’un arbre 3-aire ou
ternaire.

niveau(A) = 0, niveau(B) = niveau(C) = 1, Niveau = profondeur -1

niveau(D) = niveau(E)= niveau(F) = niveau(G) =2

La profondeur de l’arbre est égale à 3.

 Arbre binaire
 Un arbre binaire est un arbre de degré 2.
 Tout nœud de l’arbre comporte alors, zéro, un ou deux
successeurs.
 Un arbre vide est un arbre binaire
 Un arbre comportant un seul nœud est un arbre binaire, ce
nœud représente la racine.
 Un arbre comportant une racine et au maximum deux sous
arbres binaires est un arbre binaire.
 Les sous-arbres gauche et
droit sont appelés
respectivement fils gauche
et fils droit de l’arbre.
 Chaque sous-arbre est à
son tour un arbre binaire
(la structure d’arbre est
récursive )
 Le sous-arbre gauche de A est
un arbre binaire de racine B
 Le sous-arbre droit de A est
un arbre binaire de racine C
Exemple d’expression: (a-b)/((c*d)+e)

Les racines des sous-

arbres sont les
opérateurs (+, -, *, /)
Et les feuilles sont les
opérandes (a, b, c, d, e)
Arbre binaire complet
 Un arbre binaire est dit complet si tous ses nœuds internes
possèdent chacun deux fils (gauche et droit). Et si les nœuds
feuilles apparaissent aussi à gauche que possible.

Arbre binaire balancé (ou équilibré)

 On dit qu'un arbre binaire est équilibré si tous les chemins menant
de la racine à une feuille ont pour longueur la profondeur de
l’arbre ou la profondeur de l’arbre -1.
 Nombre de nœuds (sous-arbre gauche) = nombre de nœuds
(sous-arbre droit) +(-) 1
Représentation d’un arbre binaire

 Représentation contigüe: sous forme d’un tableau

d’enregistrement avec 3 champs:
 un champ info représentant l’information contenue dans
le noeud
 un champ succ_gauche donnant la position du fils
gauche dans le vecteur
 un champ succ_droit donnant la position du fils droit
dans le vecteur

Représentation contigüe ou
séquentielle
Représentation chainée dynamique
 L’arbre sera représenté par une structure dynamique non linéaire.
Chaque élément sera composé de trois champs :
 un champ info représentant l’information contenue dans le
noeud,
 un champ succ_gauche donnant l’adresse du fils gauche en
mémoire
 un champ succ_droit donnant l’adresse du fils droit en
mémoire.

Element = Enregistrement
info : <type> ; /* type de l’information contenue dans un noeud*/
succ_gauche : ptr Element;
succ_droit : ptr Element ;
Finenreg ;
noeud = ptr Elément ;
Exemple : Reprenons toujours le même exemple de l’arbre binaire
Element = Enregistrement
info : caractère ;
succ_gauche : ptr Element;
succ_droit : ptr Element ;
Finenreg ;
noeud = ptr Element ;
Racine : noeud ;
 Primitives de manipulation d’un AB

 Vide (a): booléen  vérifie si le nœud a (arbre de racine a) est

vide
 Filsgauche (a) : noeud  retourne l’adresse du fils gauche de a
 Filsdroit (a) : noeud  retourne l’adresse du fils droit de a
 Feuille (a): booléen  vérifie si le nœud a est une feuille
 Fonction Vide (E/ a : noeud) : booléen Debut
Si (a = nil) alors retourner (vrai) ; sinon retourner
(faux) ;
fsi ;
Fonction Filsdroit (E/ a : noeud) : noeud
Fin ;
Debut
retourner cont(a.succ_droit) ;
Fin ;

Fonction Filsgauche (E/ a : noeud) : noeud

Debut
retourner (cont (a.succ_gauche)
Fin ;
Fonction Feuille (E/ a : noeud) : booéen ;
Debut
si cont(a.succ_gauche = nil et cont(a.succ_droit )=
nil ) alors
retourner vrai;
sinon retourner faux;
fsi;
Fin ;
Parcours d’un AB

Le parcours d’un arbre binaire se fait selon deux modes:

 Un parcours en profondeur (ou par branche)

 Un parcours en largeur (ou par niveau)

 Parcours en largeur (par niveaux)

Ce parcours traite dans cet

ordre:
 la racine (niveau 0),
 Ensuite les fils de la racine
(de gauche à droite, niveau 1)
 Ensuite, les nœuds de niveau
2
 Et ainsi de suite jusqu’à
atteindre les feuilles

Ordre de parcours des nœuds en largeur : A B C D E F G H

 Algorithme de Parcours en largeur (ou par niveau)
Ce parcours utilise une file pour traiter les éléments
Procédure ParcoursLargeur (E/ racine: noeud)
Début
F: File;
Enfiler (F, racine);
Tant que (non Filevide (F)) Faire
Défiler (F, a); Ecrire cont(a.info);
Si (non vide (FilsGauhe(a))
alors Enfiler (Filsgauche(a));
Fsi;
Si non vide (FilsDroit(a))
alors Enfiler (FilsDroit(a));
Fsi;
Fait;
Fin Ordre de parcours des nœuds en largeur : A B C D E F GH
 Procédure ParcoursLargeur (E/
Parcours en largeur racine: noeud)
affichage File Début
F: File;
 F : a0 A Enfiler (F, racine);
 F : a1  a4 B Tant que (non Filevide (F)) Faire
 F : a4  a2  a3 C Défiler (F, a); Ecrire cont(a.info);
Si (non vide (FilsGauhe(a))
 F : a2  a3  a5 D alors Enfiler (Filsgauche(a));
 F : a3  a5 E Fsi;
Si non vide (FilsDroit(a))
 F : a5  a6 a7 F
alors Enfiler (FilsDroit(a));
 F : a6 a7 G Fsi;
 F : a7 H Fait;
Fin
 F : vide
Parcours en profondeur

 Il existe trois algorithmes de parcours d’un arbre

binaire en profondeur . Ces algorithmes opèrent de
manière récursive
 Ces algorithmes sont:
 Parcours préfixé : (racine, filsgauche, filsdroit)
 Parcours infixé: (filsgauche, racine, filsdroit)
 Parcours postfixé: (filsgauche, filsdroit, racine)
Parcours Préfixé (Racine, filsgauche, filsdroit)
 On commence par visiter (et traiter) la racine
 On effectue ensuite un parcours préfixé de tous les nœuds de A1
(fils gauche) jusqu’aux feuilles.
 On revient pour effectuer ensuite un parcours préfixé de tous les
nœuds de A2 (fils droit).

Exemple

L’ordre de parcours des nœuds est: A B D E C F

 Parcours Préfixé (R, G, D)
Procédure Préfixe (E/ a : noeud)
Début
Si (non Vide(a)) alors
Ecrire cont(a.info) ; // traitement de la racine
Si (non Feuille (a)) alors
Préfixe (Fils_gauche(a)) ; /* 1er appel récursif */
Préfixe (Fils_droit(a)) ; //@/* 2ème appel récursif */
fsi ;
fsi ; Les fils droits sont traités au retour
@ : adresse de retour après le
Fin ;
premier appel récursif

Ordre de parcours des nœuds : A B C D E F G H

Parcours Infixé (filsgauche, Racine, filsdroit)
On effectue d’abord un parcours infixé de tous les nœuds de
A1 (fils gauche) jusqu’aux feuilles. On revient ensuite à la
racine On revient pour effectuer ensuite un parcours infixé
de tous les nœuds de A2 (fils droit).

Exemple

L’ordre de parcours des nœuds est: D B E A C F

 Parcours Infixé (G, R, D)
Procédure Infixe (E/ a : noeud);
Début
Si (non Vide(a)) alors
Si (Feuille (a)) alors
Ecrire cont(a.info) ; // traitement de la racine
sinon
Infixe (Fils_gauche(a)) ; /* 1er appel récursif */
Ecrire cont(a.info) ; //@// traitement de la racine
Infixe (Fils_droit(a)) ; /* 2ème appel récursif */
fsi ;
fsi ; Fin ;

Ordre de parcours des nœuds D B E A G F H C

 Parcours Postfixé (filsgauche, filsdroit, Racine)
 On effectue d’abord un parcours postfixé de tous les noeuds
de A1 (fils gauche) jusqu’aux feuilles.
 On revient pour effectuer ensuite un parcours postfixé de
tous les noeuds de A2 (fils droit).
 On revient ensuite à la racine

Exemple

L’ordre de parcours des nœuds est: D E B F C A

 Parcours Postfixe (G, D,R)
Procédure Postfixe (E/ a : noeud);
Début
Si (non Vide(a)) alors
Si (Feuille (a)) alors Ecrire cont(a.info) ; //
traitement de la racine
sinon
Postfixe (Fils_gauche(a)) ; /* 1er appel récursif *
Postfixe (Fils_droit(a)) ; /* 2ème appel récursif
*/adresse de retour @1
Ecrire cont(a.info) ; //adresse de retour @2//
//traitement de la racine
fsi ;
fsi ;
Fin ;

Ordre de parcours des nœuds D E B G H F C A

Remarques
 Les trois types de parcours peuvent s’écrire aussi de
manière itérative en utilisant une pile. Mais la version
récursive est plus simple à écrire et à retenir
 Il s’agit d’algorithmes standards de parcours
d’arbres  Pour effectuer d’autres traitements (autre que
l’affichage), il suffit de reprendre l’algorithme tel quel
et changer l’instruction écrire par le traitement que
l’on veut effectuer
Arbre Binaire Ordonné
Un arbre binaire de recherche est un arbre binaire possédant les
propriétés suivantes:
 Pas de répétition d’éléments
 Pour chaque nœud Nœud , la valeur de N doit être
strictement supérieure à tout élément contenu dans le
fils gauche de N
 la valeur de N doit être strictement inférieure à tout
élément contenu dans le fils droit de N
 Exemple

schématiser un arbre binaire

ordonné contenant les valeurs
entières suivantes : 100, 89, 60,
190, 65, 45, 200, 140, 95
Recherche dans un arbre binaire ordonné

La recherche dans un arbre binaire ordonné se fait de

manière dichotomique:
 démarrer la recherche à partir de la racine de l’arbre
 comparer la valeur recherché à la valeur du nœud courant a
 si la valeur est égale à l’information du nœud a  arrêt,
valeur trouvée
 si la valeur est plus petite que l’information de a , s’orienter
vers le sous-arbre gauche de a
 si la valeur est plus grande que l’information de a, s’orienter
vers le sous-arbre droit de a
 si on arrive à nil  arrêt, valeur non trouvée
Exercice
Ecrire les actions paramétrées suivantes:
 recherche une valeur val et retourne son adresse
dans un arbre ordonné (d’entiers)

 insérer une valeur dans un arbre binaire ordonné

 supprimer un nœud dans un arbre binaire ordonné