Arbres Binaires

1
Arbres binaires
CHAPITRE :
I- Introduction : 2
Une expression arithmétique peut être représentée sous forme d'un arbre
syntaxique.
Soit l'expression:
(y/2−t)×(75 +z)
3
Exemple :
Soit l'expression suivante :
x-((y+1)*(Z/3))
Tracez l'arbre syntaxique correspondant

Solution : 4
x *
+ /
Y 1 Z 3
II- Définition 1: 5
Un arbre est un ensemble organisé de nœuds :

 chaque nœud a un père et un seul,
 un seul nœud la racine n’a pas de père.
 Les fils d’un nœud p sont les nœuds

dont le père est p
 Les feuilles d’un arbre sont les nœuds
qui n’ont pas de fils
Définition 2 : 6
Un arbre est constitué

 d’un noeud p, sa racine,
 d’une suite de sous-arbres (a1, a2, . . . , ak).
Les racines des arbres a1, a2, . . . , ak sont les fils de p

III- Représentation des arbres 7
binaire
En Python, les arbres binaires peuvent être représentés par
plusieurs moyens.
Dans la suite de ce cours nous allons représenter ces arbres par
une liste de listes.
 Chaque sous-arbre sera représenté à l'aide d’une liste :

 Arbre = [ racine, [ sous arbre 1] , [ sous arbre 2],…]
 Chaque feuille sera représentée à l'aide d'une liste :
 Feuille =[ nomDeLaFeuille , [ ], [ ],….]
Exemple 8
Soit l'arbre suivant :
['A',
['B', ['E', []], ['F', []] ],

['C', [] ],
['D', ['G', []],['H', []] ]
]
Exemple 2: 9
Représentez l'arbre suivant en utilisant une liste de listes:

Exemple 2: 10
[ 'A',
['B', ['D', []], ['E', []] ],

['C', ['F', []], ['G',[]] ]
]
IV- Arbre binaire : 11
 Dans un arbre binaire, chaque élément possède au plus deux

éléments fils au niveau inférieur.
 Dans un arbre binaire, chaque élément possède au plus deux
éléments fils au niveau inférieur, habituellement appelés fils
gauche et fils droit.
 Le parcours d'un arbre peut se faire en profondeur ou en
largeur de la gauche vers la droite (resp : de la droite vers la
gauche)
 Remarque :
Par la suite une feuille d'un arbre binaire, sera constituée de deux
listes vides, une représente le fils gauche et l'autre le fils droit
Feuille =[ nomDeLaFeuille , [] , [] ]
Parcourir en profondeur d'un 12
arbre n-aire:
def parcoursEnProfondeur(arbre):
n=len(arbre)
sommet = arbre[0]
print(sommet)
for i in range(1,n):
if arbre[i]!=[] :
parcoursEnProfondeur(arbre[i])
Parcourir en largeur d'un arbre n-aire: 13
def parcoursEnLargeur(arbre):
fifo = [arbre]
while fifo:
arbre_courant = fifo.pop(0)
n= len(arbre_courant)
sommet_courant = arbre_courant[0]
print(sommet_courant)
for i in range(1,n):
if arbre_courant[i] !=[] :
fifo.append(arbre_courant[i])
Parcourt préfixe :(arbre binaire) 14
def prefixe(arbre) :
if arbre!=[] :
print(arbre[0])
prefixe(arbre[1])
prefixe(arbre[2])
Parcourt infixe :(arbre binaire) 15
def infixe(arbre) :
if arbre!=[] :
infixe(arbre[1])
print(arbre[0])
infixe(arbre[2])
Parcourt postfixe : (arbre binaire) 16
def postfixe(arbre) :
if arbre!=[] :
postfixe(arbre[1])
postfixe(arbre[2])
print(arbre[0])
Tri par tas : (Tri Maximier) 17
 L'idée qui sous-tend cet algorithme consiste à voir le tableau

comme un arbre binaire.
 Le premier élément est la racine, le deuxième et le troisième
sont les deux descendants(fils) du premier élément, etc.
 Ainsi le ne élément a pour enfants les éléments 2n et 2n+1. Si le
tableau n'est pas de taille n>1, les branches ne se finissent pas
toutes à la même profondeur
 Dans l'algorithme, on cherche à obtenir un tas, c'est-à-dire un arbre binaire
vérifiant les propriétés suivantes (les deux premières propriétés découlent de
la manière dont on considère les éléments du tableau) :
• La différence maximale de profondeur entre deux feuilles est de 1 (i.e.
toutes les feuilles se trouvent sur la dernière ou sur l'avant-dernière
ligne) ;
• Les feuilles de profondeur maximale sont « tassées » sur la gauche.
• Chaque nœud est de valeur supérieure (resp. inférieure) à celles de ses
deux fils, pour un tri ascendant (resp. descendant).
 Il en découle que la racine du tas (le premier élément) contient la valeur
maximale (resp. minimale) de l'arbre. Le tri est fondé sur cette propriété.
 Les figures suivantes montrent l'action de tri Maximier sur le
tableau [4,1,3,2,16,9,10,14,8,7].
 Etape 1 : Création du tas ( la racine contient le maximum)
Etape 2 : tri croissant du tableau et vidage du tas

def tamiser(arbre, debut, fin):
pere = debut
40
fils = pere * 2 + 1
while fils<= fin:
if fils < fin and arbre[fils] < arbre[fils + 1]:
fils += 1
if arbre[pere] < arbre[fils]:
arbre[pere], arbre[fils] =
arbre[fils], arbre[pere]
pere = fils
fils=pere*2 + 1
else:
break
41
def tri_par_tas(arbre):
n=len(arbre)
for debut in range((n//2)-1, -1, -1):
tamiser(arbre, debut, n-1)
for fin in range(n-1, 0, -1):

arbre[fin], arbre[0] = arbre[0],
arbre[fin]
tamiser(arbre, 0, fin-1)
return arbre
Complexité O(n log(n) )

Arbres Binaires

Transféré par

Droits d'auteur :

Formats disponibles

Arbres Binaires

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Arbres Binaires

Transféré par

Droits d'auteur :

Formats disponibles

1

Tracez l'arbre syntaxique correspondant

Un arbre est un ensemble organisé de nœuds :

 Les fils d’un nœud p sont les nœuds

Un arbre est constitué

Les racines des arbres a1, a2, . . . , ak sont les fils de p

 Chaque sous-arbre sera représenté à l'aide d’une liste :

['B', ['E', []], ['F', []] ],

Représentez l'arbre suivant en utilisant une liste de listes:

['B', ['D', []], ['E', []] ],

 Dans un arbre binaire, chaque élément possède au plus deux

 L'idée qui sous-tend cet algorithme consiste à voir le tableau

Etape 2 : tri croissant du tableau et vidage du tas

for fin in range(n-1, 0, -1):

Complexité O(n log(n) )

Vous aimerez peut-être aussi