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
Tri par tas : (Tri Maximier) 18
 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é.
Tri par tas : (Tri Maximier) 19
 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)
Tri par tas : (Tri Maximier) 20
Tri par tas : (Tri Maximier) 21
Tri par tas : (Tri Maximier) 22
Tri par tas : (Tri Maximier) 23
Tri par tas : (Tri Maximier) 24
Tri par tas : (Tri Maximier) 25
Tri par tas : (Tri Maximier) 26
Tri par tas : (Tri Maximier) 27

Etape 2 : tri croissant du tableau et vidage du tas

Tri par tas : (Tri Maximier) 28
Tri par tas : (Tri Maximier) 29
Tri par tas : (Tri Maximier) 30
Tri par tas : (Tri Maximier) 31
Tri par tas : (Tri Maximier) 32
Tri par tas : (Tri Maximier) 33
Tri par tas : (Tri Maximier) 34
Tri par tas : (Tri Maximier) 35
Tri par tas : (Tri Maximier) 36
Tri par tas : (Tri Maximier) 37
Tri par tas : (Tri Maximier) 38
Tri par tas : (Tri Maximier) 39
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) )