Table des matières Arbres Binaires

Arbres Binaires
Noaman Fakhir

Table des matières

1 Arbres binaires ..................................................................................................................... 2
1.1 Definitions ...................................................................................................................... 2
1.2 Exemples et terminologie ............................................................................................... 2
1.3 Structure recursive ......................................................................................................... 3
1.4 Implementation .............................................................................................................. 3
1.5 Parcours ......................................................................................................................... 4
1.5.1 Parcours en profondeur (Depth-First Search): ...................................................... 4
1.5.2 Parcours en largeur (Breadth-First Search) .......................................................... 4
2 Arbre Binaire de Becherche (Binary Search Tree) ............................................................... 5
2.1 Implementation .............................................................................................................. 5
3 Tas ....................................................................................................................................... 6
3.1 Implementation .............................................................................................................. 6
3.2 Tri par tas (Heap sort) ................................................................................................... 7

Noaman Fakhir 1/7

Table des matières Arbres Binaires

1 Arbres binaires
1.1 Definitions
En mathematique: Un arbre est un cas special de graphe acyclique oriente, ou tous les noeuds
sauf la racine ont un unique parent
En informatique: C’est une structure de données récursive utilisée pour représenter ce type
de graphes.

1.2 Exemples et terminologie

Figure 1: Un arbre contenant des entiers

Un arbre est un ensemble de noeuds et d’arete reliant ces noeuds.
Chaque noeud a une etiquette : une valeur ou donnee associee au noeud.
L’ordre ou la taille d’un arbre est le nombre de noeuds qui le compose.
La racine d’un arbre est le noeud le plus haut dans l’hierarchie de l’arbre, c’est le noeud « de
depart ».
Tous les noeuds sauf la racine ont un unique pere, c’est le noeud directement au-dessus dans
l’hierarchie.
Les noeuds ont 0, 1, ou plusieurs fils. Les noeuds sans fils sont appele feuilles de l’arbre.
Le degree d’un noeud est le nombre de fils qu’il a.
La profondeur d’un noeud est le nombre d’arete necessaire pour aller du noeud a la racine.
On s’interesse dans ce cours aux arbres binaires, c-a-d, les arbres ayant des noeuds de degree
maximum 2.

Noaman Fakhir 2/7

Exemples et terminologie Arbres Binaires

Figure 2: Classe de complexite

1.3 Structure recursive

On peut definir les arbres binaires de maniere recursive. Un arbre est :
• Soit vide, representee par une liste vide [] .
• Soit compose d’un noeud racine ayant une valeur 𝑉𝑟 , d’un sous-arbre gauche 𝐹𝑔 , et d’un
sous-arbre droit 𝐹𝑑 . On represente l’arbre par la liste [V_r, F_g, F_d] .

Exemples
• [2, [], []]
• [4, [2, [], []], [8, [1, [], []], []] ]
• [7, [3, [1, [], []], [2, [], []]], [5, [4, [], []], []] ]

1.4 Implementation

1 def cree_arbre():
2 return []
3 def arbre(R, Fg, Fd):
4 return [R, Fg, Fd]
5 def est_vide(A):
6 return A == []
7 def fils_g(A):
8 if est_vide(A): return None
9 return A[1]
10 def fils_d(A):
11 if est_vide(A): return None
12 return A[2]
13 def racine(A):
14 if est_vide(A): return None
15 return A[0]

Noaman Fakhir 3/7

Implementation Arbres Binaires

16 def est_arbre(A):
17 return est_vide(A) or (isinstance(A, list) and len(A) ==3 and
est_arbre(fils_g(A)) and est_arbre(fils_d(A))
18 def est_feuille(A):
19 return not est_vide(A) and est_vide(fils_g(A)) and est_vide(fils_d(A))

1.5 Parcours
On peut parcourir l’arbre en privilegiant la largeur, ou la profondeur.

1.5.1 Parcours en profondeur (Depth-First Search):

Prefix :
On parcourt l’arbre recursivement suivant l’ordre : 𝑉𝑟 , 𝐹𝑔 , 𝐹𝑑

Infix :
On parcourt l’arbre recursivement suivant l’ordre : 𝐹𝑔 , 𝑉𝑟 , 𝐹𝑑

Postfix :
On parcourt l’arbre recursivement suivant l’ordre : 𝐹𝑔 , 𝐹𝑑 , 𝑉𝑟

1.5.2 Parcours en largeur (Breadth-First Search)

On liste tous les fils du meme niveau de profondeur avant de passer au niveau de profondeur
suivant.

Implementation

1 def parcours_prefixe(A):
2 if est_vide(A) :
3 return []
4 return [racine(A)] + parcours_prefixe(fils_g(A)) + \
5 parcours_prefixe(fils_d(A))
6 def parcours_infixe(A):
7 if est_vide(A) :
8 return []
9 return parcours_infixe(fils_g(A)) + [racine(A)] + \
10 parcours_infixe(fils_d(A))
11 def parcours_postfixe(A):
12 if est_vide(A) :
13 return []
14 return parcours_postfixe(fils_g(A)) + parcours_postfixe(fils_d(A)) + \
15 [racine(A)]
16
17 def BFS(A):
18 F = [A]
19 while F!=[]:
20 x = F.pop(0)
21
22 # Traitement sur x
23 print(racine(x))
24
25 # Ajout des fils dans la file
26 if not est_vide(fils_g(A)):
27 F.append(fils_g(x))

Noaman Fakhir 4/7

Implementation Arbres Binaires

28 if not est_vide(fils_d(A)):
29 F.append(fils_d(x))

2 Arbre Binaire de Becherche (Binary Search Tree)

Un ABR A est un arbre binaire qui verifie les conditions suivantes :
• Les etiquettes du sous-arbre gauche sont inferieures a celle de la racine
• Les etiquettes du sous-arbre droit sont superieures a celle de la racine
• Les sous-arbres gauche et droit sont des ABR (recursivite)

Figure 3: Un ABR
On peut obtenir les etiquettes d’un ABR en ordre croissant en faisant un parcours infixe.

2.1 Implementation

1 def min_abr(ABR):
2 current = ABR
3 while not est_vide(fils_g(current)):
4 current = fils_g(current)
5 return racine(current)
6 def max_abr(ABR):
7 current = ABR
8 while not est_vide(fils_d(current)):
9 current = fils_d(current)
10 return racine(current)
11 def insert(ABR, e):
12 if est_vide(ABR):
13 ABR = [e, [], []]
14 elif e <= racine(ABR) :
15 insert(fils_g(ABR), e)
16 else :
17 insert(fils_d(ABR), e)
18
19 def search(ABR, e):
20 if est_vide(ABR) :
21 return False
22 if racine(ABR) == e:
23 return True
24 if e < racine(ABR) :
25 return search(fils_g(ABR), e)
26 if e > racine(ABR) :
27 return search(fils_d(ABR), e)
28
29 def predecessor(ABR, e):
30 if est_vide(fils_g(ABR)) :
31 return None

Noaman Fakhir 5/7

Implementation Arbres Binaires

32 return max_abr(fils_g(ABR))
33 def successor(ABR, e):
34 if est_vide(fils_d(ABR)) :
35 return None
36 return min_abr(fils_d(ABR))
37 def remove(ABR, e):
38 # ...

3 Tas
Un Tas T est un arbre binaire qui verifie les conditions suivantes :
• Il est parfait, c’est a dire tous les niveaux sauf le dernier doivent être totalement remplis et
le dernier niveau est rempli de gauche à droite.
• L’etiquette de chaque noeud est superieure ou egale (resp. inferieure ou egale) aux etiquettes
de ses fils, on parle de tas max (resp. tas min)

Figure 4: Un tas

3.1 Implementation
Le tas etant un arbre binaire parfait, on peut l’implementer en utilisant une seule liste, ou on
met la racine a l’indice 0, et pour chaque noeud i on met les fils gauche et droit aux position
2*i+1 et 2*i+2 .

Le tas precedent est donc implemente comme suit :

T = [53, 41, 30, 36, 28, 21, 6, 31, 16, 20]

1 def cree_tas():
2 return []
3 def insert(T, e):
4 # ...
5 def enleve_racine(T):
6 # ...

Noaman Fakhir 6/7

Implementation Arbres Binaires

3.2 Tri par tas (Heap sort)

On peut utiliser les tas pour faire le tri: Pour une liste L , on insere successivement les elements
de L dans un tas min, puis on enleve la racine successivement jusqu’a vider le tas, la racine
etant le min a chaque iteration, l’ordre des racine enleve sera donc croissant.

1 def tri_par_tas(L):
2 # ...

Noaman Fakhir 7/7