+arbresbinaires

CPGE OUJDA Les arbres binaires SPE
Introduction
La structure d'arbre est l'une des plus importantes et des plus spécifiques de
l'informatique.
Exemples d’utilisation :
organisation des fichiers dans les systèmes d'exploitation
internet : DNS (Dynamic Naming System)
mécanismes internes des compilateurs/interpreteurs
Il existe plusieurs types d'arbre : binaires, planaires, ...
Une propriété intrinsèque de la structure d’arbre est la récursiv ité .
Un arbre binaire (ou n-aire) est une structure de données de type hiérarchique.
Les éléments constituant un arbre ont pour nom : racine, nœuds et feuilles.
Le nœud initial est nommé racine.
Les éléments terminaux sont des feuilles.
Dans un arbre binaire, chaque élément possède au plus deux éléments fils au niveau
inférieur.
Un arbre qui possède deux voire plus de sous éléments est appelé "père", les
éléments inférieurs étant appelés des "fils".
L a h a u teur (ou p r o fondeur ) d ’un n o e ud est l a l o n g u eur du c hemin q ui le lie ` a l a r ac i n e .
A rbres b inaires
U n arb r e b i nai re est un a rb re t e l q u e l e s n œ u ds on t a u p l u s d eu x fi l s ( gau c h e e t d roi t ) .
Le s a r br es bin a i r es ( AB ) f orm e n t un e s t r u c t u r e d e d on n é e s q u i p e u t ˆ ê t r e d é fi n i e
r é c u r s i v e m e n t d e l a m an i è r e s u i v an t e : un arb r e b i nai r e e s t
– s oi t v i d e ,
– s oi t c om p os ´ e d ’ un e r ac i n e por t an t un e é t i q u e tt e ( c l é ) e t d ’ un e pai r e d ’ arb r e s b i nai r e s ,
ap p e l é s fi l s gau c h e e t d r oi t .
Exemple 1:
A rbres b inaires d e r ec herc he
A
B
C
D
E
F
G

15
U n arb r e b i nai re d e rec h erc h e e st un arb r e b i nai re qu i p oss è de l a p roprié t é f o nda men t a l e
s uiv a n t e:
– t o u s l es nœ uds du so us- a r b r e de ga u c h e d ’un n œ u d de l’a r b r e o n t une v a leur inf é rieure o u
é gal e ` a l a s i e nn e .
– t o u s l es nœ uds du so us- a r b r e de dr o i te d’un nœ ud d e l’a r b r e o n t une v a leur sup é rieure o u
é gal e ` a l a s i e nn e .
Parcours d'un arbre binaire :
Le parcours le plus simple à programmer est le parcours dit en profondeur d’abord. Son
principe est simple : 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.
Parcours préfixe, (NGD) :_ tout Nœud est suivi des nœuds de son sous-arbre Gauche puis des
nœuds de son sous-arbre Droit 12
Affichage_pr e fixe(AB a)
si NON est_vide(a)
Afficher val(a)
Affichage_pr e fixe(fils_gauche(a))
Affichage_pr e fixe(fils_droit(a))
1 7
91 67 82
61
12 1 91 67 7 82 61
Parcours infixe, ou symétrique (GND) :_ tout Nœud est précédé des nœuds de
son sous-arbre Gauche et suivi des nœuds de son sous-arbre Droit
Affichage_infixe(AB a)
si NON est_vide(a)
Affichage_infixe(fils_gauche(a))
Afficher val(a)
Affichage_infixe(fils_droit(a))
91 1 67 12 7 61 82
10
19
8
12
14
22
2
11
20
25

Parcours suffixe, post-fixe (GDN) :_ tout Nœud est précédé des nœuds de son sous-arbre
Gauche et des nœuds de son sous-arbre Droit
Affichage_postfixe(AB a)
si NON est_vide(a)
Affichage_postfixe(fils_gauche(a))
Affichage_postfixe(fils_droit(a))
Afficher val(a)
91 67 1 61 82 7 12
Parcours en largeur.
 Visite les nœuds niveau par niveau depuis la racine:
 Peut-être décrit facilement en utilisant une File.
affichageLargeur(a):
F : File #File FIFO
Enfiler(a,F) #enfiler la racine a dans la file F
tantque non vide(F):
n=Défiler(F)
si non vide(n):
Afficher(val(n))
Enfiler(filsGauche(n),F)#enfiler fils gauche de n dans f
Enfiler(filsDroit(n),F) #enfiler fils droit de n dans F
I m pl ´ e m e n t a t i o n e n P y t ho n pa r de s li s t e s
On i mp l ´ e m e n t e l es arb r es b i nai r es n on v i d es par d es li s t es d e t r oi s ´ e l ´ e m e n t s :
[valeur,[fils gauche],[fils droit]] . Ou bien ,[[fils gauche], valeur, [fils droit]] .
Exemples :
A= [20,[],[]] #A est un arbre qui contient un seul nœud (20)
20
A= [20, [ 5, [], [] ] , [ 3, [], [] ] ]
A=[20, [ 5, [10,[],[] ], [14,[],[]] ] , [ 3, [], [] ] ]
A=[20, [ 5, [10,[],[] ], [14,[],[]] ] , [ 3, [22,[],[]], [29,[],[]] ] ]

EXERCICES
Exercice1
En utilisant la forme
,[[fils gauche], valeur, [fils droit]] . Ecrire en python les
fonctions suivantes ;
1) def inserer(r, x): qui insert un noeud x dans notre arbre binaire de recherche r
2) def prefixer(r):, def infixer(r):, et def postfixer(r): selon les algorithmes précédents
3) def liste_vers_arbre(liste): """création d'un arbre à partir d'une liste"""
Exercice2 :
En utilisant la forme
[valeur, [fils gauche], [fils droit]]
Ecrire les fonctions
suivantes :
1) Fonction qui détermine si un arbre a est vide ou non.
2) Fonction qui retourne la valeur de la racine d’un arbre (étiquette).
3) Fonction qui retourne le fils gauche de l’arbre a .
4) Fonction qui retourne le fils Droit de l’arbre a .
5) Fonction qui fait le Parcourt d’ un arbre en largeur
6) Déterminer si un nœud est une feuille
7) Hauteur d’un arbre
8) Calculer le nombre de nœuds d’un arbre
9) Calculer le nombre de feuilles dans un arbre
10) Fonction de recherche dans un arbre binaire quelconque

Solutions
Exercice1 :
def inserer(r, x):
"""insertion d'un noeud dans notre arbre binaire"""
if r == []:
r.append([])
r.append(x)
r.append([])
elif x < r[1]: inserer(r[0], x)
else: inserer(r[2], x)
def prefixer(r):
"""parcours préfixé"""
if r == []: return None
else:
print r[1],
prefixer(r[0])
prefixer(r[2])
def infixer(r):
"""parcours infixé"""
if r == []: return None
else:
infixer(r[0])
print r[1],
infixer(r[2])
def postfixer(r):
"""parcours postfixé"""
if r == []: return None
else:
postfixer(r[0])
postfixer(r[2])
print r[1],
def liste_vers_arbre(liste):
"""création d'un arbre à partir d'une liste"""
arbre = []
for i in liste: inserer(arbre, i)
return arbre
import random
liste = []
for i in range(50):
liste.append(i)