CPGE - Privé Informatique Mr : L.

BOUHOU
Lydex – Ben Guérir Programmation MP / 2TSI /PSI
Les Arbres
I-Définition
Un arbre est formé par un nœud (dit « racine »), le plus haut placé dont dérivent tous les autres nœuds(qui peuvent être
des sous-arbres).
Un nœud n'ayant pas des sous-arbres est dit « feuille ». Les autres nœuds sont dits « nœuds internes ».

Il existe une relation de parenté entre les nœuds. Un nœud père est situé au-dessus de ses nœuds fils.
Un nœud père est relié à ses fils par des arcs.
Un arbre est une structure de données récursive.
Arité d'un arbre
Un arbre dont les nœuds ne comporteront qu'au maximum n fils sera d'arité n. On parlera alors d'arbre n-aire.
On appelle degré d'un nœud, le nombre de fils que possède ce nœud.
Les fils d’un arbre sont habituellement ordonnés de gauche à droite.
Taille et profondeur d’un nœud.
On appelle la taille d'un arbre, le nombre de nœud interne qui le compose. C'est à dire le nombre nœud total moins le
nombre de feuille de l'arbre.
On appelle également la profondeur d'un nœud la distance en terme de nœud par rapport à l'origine. Par convention, la
racine est de profondeur 0.
Dans l'exemple suivante:
La taille de l’arbre est : 4
Le nœud F est de profondeur 2
Le nœud H est de profondeur 3.

hauteur d'un arbre

La hauteur d‘un arbre est la profondeur maximale de ses nœud. C'est à dire la profondeur à laquelle il faut descendre dans
l'arbre pour trouver le nœud le plus loin de la racine.
On peut aussi définir la hauteur de manière récursive : la hauteur d'un arbre est le maximum des hauteur ses fils. C'est à
partir de cette définition que nous pourrons exprimer un algorithme de calcul de la hauteur de l'arbre.
Arbre Binaire / dégénéré / localement complet
Un arbre binaire est un cas particulier d’arbre n-aire. Dans un tel arbre, les
nœuds ont au maximum 2 fils: un fils gauche et un fils droit.
Un Arbre binaire dégeneré ou filiforme est un arbre binaire où chaque
nœud a un seul fils.

Un arbre binaire localement complet est un arbre binaire dont chacun des
nœuds possèdent soit 0 soit 2 fils. C.à.d.: les nœuds internes ont tous deux
fils.

Dans ce type d'arbre, on peut établir une relation entre la taille de l'arbre et
le nombre de feuille. En effet, un arbre binaire localement complet de taille
n aura n+1 feuille.

1
 CPGE - Privé Informatique Mr : L. BOUHOU
Lydex – Ben Guérir Programmation MP / 2TSI /PSI
Arbre Binaire complet
On appellera arbre binaire complet tout arbre qui est localement complet et
dont toutes les feuilles ont la même profondeur.

Dans ce type d'arbre, on peut exprimer le nombre de nœuds n de l'arbre en

fonction de la hauteur h :
n = 2h+1 -1.
Exemple : Représentation des expressions arithmétiques.
Les nœuds internes ont pour étiquettes les opérateurs.
les feuilles sont étiquetées par des identificateurs

II. Mise en œuvre des arbres binaires

En python, on peut représenter un arbre vide par une liste vide [] et un arbre binaire non vide par une liste comprenant 3
éléments [clé, fils gauche, fils droit].
Exemple:

III. Manipulation des arbres binaires(A.B.)

 Fonction qui détermine si un A.B. est ou non vide:  Fonction qui retourne la valeur de la racine d’un A.B.:
def EstVide(a): def val(a):
return a==[] if EstVide(a)==False: return a[0]
return None
 Fonction qui retourne la valeur du fils gauche d’un  Fonction qui retourne la valeur du fils droit d’un nœud:
nœud: def FilsDroit(a):
def FilsGauche(a): if EstVide(a)==False: return a[2][0]
if EstVide(a)==False: return a[1][0] return None
return None
 Fonction qui retourne le ss. Arbres Gauche d’un nœud:  Fonction qui retourne le ss. Arbres Droit d’un nœud:
def SArbreGauche(a): def SArbreDroite(a):
if EstVide(a)==False: return a[1] If EstVide(a)==False: return a[2]

 Fonction qui teste si un nœud ets ou non une feuille:  Fonction qui détermine la hauteur d’un Arbre:
def EstFeuille(a): def hauteur(a):
if EstVide(a)==True:return False if EstVide(a) or EstFeuille(a):return 0
return EstVide(a[1]) and EstVide(a[2]) return 1+
max(hauteur(SArbreGauche (a)),
hauteur(SArbreDroite (a)))

2
 CPGE - Privé Informatique Mr : L. BOUHOU
Lydex – Ben Guérir Programmation MP / 2TSI /PSI
 Fct. qui détermine le nombre de nœuds dans un A.B:  Fct. qui détermine le nombre de feuilles dans un A.B:
def NbrFeuille(a):
def NbrNoeud(a): if EstVide(a):return 0
if EstVide(a):return 0 elif EstFeuille(a):return 1
return 1+ NbrNoeud(SArbreGauche(a)) + return NbrFeuille(SArbreGauche(a)) +
NbrNoeud(SArbreDroite(a)) NbrFeuille(SArbreDroite(a))
 Fct. qui détermine si un nœuds est ou non interne:  Fct. qui détermine le nbre de nœuds internes dans un AB:
def EstNoeudInt(a): def NbrNoeudInt(a):
if EstVide(a):return False if EstVide(a):return 0
return not EstFeuille(a) elif EstFeuille(a):return 0
return 1 + NbrNoeudInt(SArbreDroite(a)) +
NbrNoeudInt(SArbreGauche(a))
 Fonction qui recherche si un élément figure ou non dans un A.B.:
def Existe(a,x):
if EstVide(a):return False
elif val(a)==x:return True
return Existe(SArbreGauche(a),x) or Existe(SArbreDroite(a),x)
 Parcours d’un A.B.:
1- Parcours en profondeur:
on distinct 3 façons d’établir le parcours en profondeur:
a-Parcours Préfixé:
il est décrit récursivement:
 Visiter la racine
 Visiter le sous arbre gauche en parcours préfixe
 Visiter le sous arbre droit en parcours préfixe

Ainsi, un parcours préfixé pour cet arbre va nous donner comme résultat : 11;8;5;10;14;13;15
Implémentation du Parcours Préfixé en python:
def ParcoursPrefixe(a):
if EstVide(a)==False: print(val(a),end=' - ')
ParcoursPrefixe(SArbreGauche(a))
ParcoursPrefixe(SArbreDroite(a))
b-Parcours infixé:
il est décrit récursivement:
 Visiter le sous arbre gauche en parcours infixe
 Visiter la racine
 Visiter le sous arbre droit en parcours infixe

Un parcours infixé pour cet arbre va nous donner comme résultat : 5;8;10;11;13;14;15
Implémentation du Parcours infixé en python:

3
 CPGE - Privé Informatique Mr : L. BOUHOU
Lydex – Ben Guérir Programmation MP / 2TSI /PSI
def ParcoursInfixe(a):
if EstVide(a)==False:
ParcoursInfixe(SArbreGauche(a))
print(val(a),end=' - ')
ParcoursInfixe(SArbreDroite(a))
c- Parcours Post-fixé
il est décrit récursivement:
 Visiter le sous arbre gauche en parcours Post-fixé
 Visiter le sous arbre droit en parcours Post-fixé
 Visiter la racine

Un parcours Post-fixé pour cet arbre va nous donner comme résultat : 5;10;8;13;15;14;11
Implémentation du Parcours Post-fixé en python:
def ParcoursPostfixe(a):
if EstVide(a)==False:
ParcoursPostfixe(SArbreGauche(a))
ParcoursPostfixe(SArbreDroite(a))
print(val(a),end=' - ')