Chap05 - Les arbres - Arbre binaire de recherche (ABR)

>1 de 11

Chap05 Les arbres - rabre binaire de recherche (ABR)-Diapos

(MP2)
Gossoni Mohamed
mohamedgossoni@gmail.com
Plan Al khansa - CPGE MP

Introduction:
I - Définition et exemple:
1. Définition:
2. ABR et le parcours infixé:
II - Les opérations sur l’ABR:
1. La recherche:
a. Existence d'une valeur:
b. Recherche du maximum (minimum):
2. La modification:
a. Insertion:
b. Suppression:
3. Le tri par ABR:
4. Analyse de la complexité:

Introduction: Dans ce chapitre on introduit une structure de donnée basée sur la notion de
l’arbre binaire, et on évaluera sa performance par rapport à la résolution des problèmes suivants:
1. Effectuer une recherche, modification de valeur ou modification de structure (suppression et
insertion). 2. Trier des données

Définition 1 (AB complet & AB dégénéré en liste)

• Un arbre binaire complet est un AB dont tous les nœuds autre que les feuilles ont 2 fils et
toutes les feuilles sont à la même profondeur.
• Un arbre binaire dégénéré en liste est un AB dont tous les nœuds autre que les feuilles ont
exactement un seul fils.

1
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>2 de 11

Exemple 1

Théorème (Hauteur d’un AB complet & AB dégénéré en liste):

1. La hauteur d’un arbre binaire complet de 𝑛 nœuds, est ℎ = 𝑙𝑜𝑔2 (𝑛 + 1) − 1.
2. La hauteur d’un arbre binaire dégénéré de 𝑛 nœuds, est ℎ = 𝑛 − 1.

Preuve:
ℎ
1. 𝑛 = ∑ 2𝑖 = 2ℎ+1 − 1 ⟹ ℎ = 𝑙𝑜𝑔2 (𝑛 + 1) − 1.
𝑖=0
2. Immédiate.

Corollaire Soit 𝑛 le nombre de nœuds d’un arbre binaire 𝐴 et ℎ sa hauteur.

On a: ⌊𝑙𝑜𝑔2 (𝑛)⌋ ≤ ℎ ≤ 𝑛 − 1

Preuve:
1. Soit 𝐵 un arbre binaire complet de même hauteur ℎ que 𝐴. Il est claire que 𝑛 ≤ |𝐵|.
Or d’après le théorème: 𝑛 ≤ 2ℎ+1 − 1 donc 𝑛 < 2ℎ+1
d’où 𝑙𝑜𝑔2 (𝑛) < ℎ + 1 et par passage à la partie entière inferieur: ⌊𝑙𝑜𝑔2 (𝑛)⌋ < ℎ + 1 c.a.d
⌊𝑙𝑜𝑔2 (𝑛)⌋ ≤ ℎ.
2. Soit 𝐶 un arbre binaire dégénéré en liste de même nombre 𝑛 de nœuds que 𝐴. On a alors
ℎ ≤ ℎ(𝐶) = 𝑛 − 1.
Conclusion: ⌊𝑙𝑜𝑔2 (𝑛)⌋ ≤ ℎ ≤ 𝑛 − 1.

Définition2 (Arbre binaire équilibré & arbre binaire dégénéré)

1. Un arbre binaire équilibré est un arbre dont la hauteur ℎ est en 𝑂(𝑙𝑜𝑔2 (𝑛)).
2. Un arbre binaire dégénéré est un arbre dont la hauteur ℎ est en 𝑂(𝑛).

Exemple 2
1. Un arbre binaire complet est un arbre équilibré. On dit même parfaitement équilibré.
2. Un arbre binaire dégénéré en liste est un arbre dégénéré.

2
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>3 de 11

1 I - Définition et exemple:
1.1 1) Définition:
Définition : (ABR) Un arbre binaire 𝐴 est un arbre binaire de recherche (en anglais, binary
search tree ou BST) s’il est:
1. Soit vide (𝐴 = [ ]).
2. Soit égal à l’arbre binaire 𝐴 = [𝑟, 𝐴𝑔, 𝐴𝑑] où :
• 𝐴𝑔 et 𝐴𝑑 sont des arbres binaires de recherche.
• Toute valeur de 𝐴𝑔 est inférieure (ou égale) à 𝑟.
• Toute valeur de 𝐴𝑑 est supérieure (ou égale) à 𝑟.

Remarque :
1) D’après la définition d’un 𝐴𝐵𝑅, les données utilisées comme étiquettes doivent être de valeur
ordonnable, sinon on leur associe (par un dictionnaire) des étiquettes ordonnable.
2) Tout comme les graphes en générale on distingue entre le nœud ( élément de la structure) et
la valeur (étiquette ou donnée que représente ou porte ce nœud ).

Exemple :

1.2 2) ABR et le parcours infixé:

Théorème : A est un 𝐴𝐵𝑅 si est seulement si la visite de ses nœuds par un parcours infixé
retourne les valeurs des nœuds en ordre croissant.

Preuve: (par induction forte sur la taille 𝑛 de |𝐴|): ⇒

• Cas de base (𝑛 = 0): Si 𝐴 = [], rien à prouver.

3
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>4 de 11

• Hypothèse (𝑛 > 0): Dans tout 𝐴𝐵𝑅 de taille < 𝑛 le parcours infixé de se fait par ordre
croissant.
• Induction (𝑛): Soit 𝐴 = [𝑟, 𝐴𝑔 , 𝐴𝑑 ] un 𝐴𝐵𝑅 de taille |𝐴| = 𝑛.
– On a 𝐴𝑔 et 𝐴𝑑 sont 2 𝐴𝐵𝑅 de taille < 𝑛 donc par l’hypothèse 𝑝𝑎𝑟𝑐𝑜𝑢𝑟𝑠𝐼𝑛𝑓𝑖𝑥𝑒(𝐴𝑔 ) et
𝑝𝑎𝑟𝑐𝑜𝑢𝑟𝑠𝐼𝑛𝑓𝑖𝑥𝑒(𝐴𝑑 ) se font par ordre croissant.
– Comme toute valeur de 𝐴𝑔 est inférieure à la valeur de 𝑟 et toute valeur de 𝐴𝑑 est
supérieure à la valeur de 𝑟, le parcours 𝑝𝑎𝑟𝑐𝑜𝑢𝑟𝑠𝐼𝑛𝑓𝑖𝑥𝑒(𝐴𝑔 ) → 𝑟 → 𝑝𝑎𝑟𝑐𝑜𝑢𝑟𝑠𝐼𝑛𝑓𝑖𝑥𝑒(𝐴𝑑 )
est bien effectué par ordre croissant de valeur.
⇐ ( Même démarche).
• Cas de base (𝑛 = 0): Si |𝐴| = 0, alors 𝐴 = [] est un arbre binaire de recherche.
• Hypothèse (𝑛 > 0): Tout 𝐴𝐵 d’ordre < 𝑛 tel que son parcours infixé se fait par ordre
croissant est un 𝐴𝐵𝑅.
• Induction (𝑛): Soit 𝐴 = [𝑟, 𝐴𝑔 , 𝐴𝑑 ] un 𝐴𝐵 d’ordre |𝐴| = 𝑛 tel que son parcours infixé
𝑝𝑎𝑟𝑐𝑜𝑢𝑟𝑠𝐼𝑛𝑓𝑖𝑥𝑒(𝐴𝑔 ) → 𝑟 → 𝑝𝑎𝑟𝑐𝑜𝑢𝑟𝑠𝐼𝑛𝑓𝑖𝑥𝑒(𝐴𝑑 ) se fait par ordre croissant.
– Comme |𝐴𝑔 | < 𝑛 et |𝐴𝑑 | < 𝑛 alors d’après 𝐻.𝑅: 𝐴𝑔 et 𝐴𝑑 sont des 𝐴𝐵𝑅s.
– Donc par définition 𝐴 est un 𝐴𝐵𝑅.

Exemple :
A=[25,
[10,
[5,[],[9,[],[]]],
[15,[12,[],[]],[]]],
[30,
[25,[],[28,[],[]]],
[35,[33,[],[]],[37,[36,[],[]],[]]]
]
]

def parcoursInfixe(A):
if A==[]:
return []
return parcoursInfixe(A[1])+[A[0]]+parcoursInfixe(A[2])

parcoursInfixe(A)
Ça donne: [5, 9, 10, 12, 15, 25, 25, 28, 30, 33, 35, 36, 37]

2 II - Les opérations sur l’ABR:

Dans un ABR l’opération de recherche est naturelle. La structure est conçue pour être adaptée à
la recherche.

2.1 1) La recherche:
2.1.1 a. Existence d’une valeur:
Principe Même principe que la dichotomie.

4
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>5 de 11

Algorithmes

Algorithme récursif:
fonction: existRec(A,x)
Entrée: A un ABR et x la valeur recherchée
Sortie: Vrai pour x parmi les valeurs de A ou Faux sinon.
Si A est vide alors:
Retourner Faux
r ← racine(A)
Si r=x alors:
Retourner Vrai
Ag ← sous arbre gauche de r
Si r>x alors:
Retourner existRec(Ag,x)
Ad ← sous arbre droit de r
Si r<x alors:
Retourner existRec(Ad,x)

Algorithme itératif:
fonction: existIt(A,x)
Entrée: A un ABR et x la valeur recherchée
Sortie: Vrai pour x parmi les valeurs de A ou Faux sinon.
Tant que A non vide faire:
r ← racine(A)
Si r=x alors:
retourner Vrai
Si r>x alors:
A ← sous arbre gauche de r

5
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>6 de 11

Si r<x alors:
A ← sous arbre droit de r
Retourner Faux

2.1.2 b. Recherche de la valeur Max (Min):

Principe Par construction de l’ABR, la plus grande valeur est portée par le nœud le plus à droite
et la plus petite valeur est portée par le nœud le plus à gauche.

Algorithmes

Algorithme récursif:
fonction: rechercheMinRec(A)
Entrée: A un ABR
Sortie: La valeur minimum.
Si A est vide alors:
retourner Nul
r ← racine(A)
Ag ← sous arbre gauche de r
Si Ag est vide alors:
retourner r
Retourner rechercheMinRec(Ag)

Algorithme itératif:
fonction: rechercheMaxIt(A)
Entrée: A un ABR
Sortie: La valeur maximum.
Tant que A est non vide faire:

6
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>7 de 11

r ← racine(A)
Ad ← sous arbre droit de r
Si Ad est vide alors:
retourner r
A ← Ad
Retourner Nul

2.2 2) Les modifications dans un ABR:

Les opérations de modification suivantes sur l’ABR 𝐴, doivent préserver la nature de 𝐴.

2.2.1 a. Insertion:
Principe L’insertion se fait au niveau des feuilles en partant de la racine. L’idée est pareille à
celle de la recherche: On cherche la feuille adéquate et le nouveau nœud sera son fils.

Algorithmes

Algorithme récursif:
fonction: insertionRec(A,v).
Entrée: A un ABR et v une valeur à insérer.
Sortie: ABR reconstruit en insérant v dans A.
Si A est vide alors:
retourner A avec un unique nœud de valeur v
Sinon:
r ← racine(A)
Si v<=r alors:
Ag ← sous arbre gauche de r
Retourner insertionRec(Ag,v)

7
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>8 de 11

Sinon:
Ad ← sous arbre droit de r
Retourner insertionRec(Ad,v)

Algorithme itératif:
fonction: insertionIt(A,v).
Entrée: A un ABR et v une valeur à insérer.
Sortie: ABR reconstruit en insérant v dans A.
Si A est vide alors:
retourner A avec un unique nœud de valeur v
Booléen ← Vrai
Tant que Booléen faire:
r ← racine(A)
Si v<=r alors:
Ag ← sous arbre gauche de r
Si Ag est vide alors:
[v,[],[]] est fils gauche de r.
Booléen ← Faux
Sinon alors:
A ← Ag
Sinon alors:
Ad ← sous arbre droit de r
Si Ad est vide alors:
[v,[],[]] est fils droit de r.
Booléen ← Faux
Sinon alors:
A ← Ad

2.2.2 b. Suppression:
Principe La suppression d’un nœud 𝑛, en générale, se fait par l’élimination de 𝑛 s’il n’a pas
de fils (feuille) ou son remplacement par 𝑝𝑟𝑒𝑑(𝑛) (ou 𝑠𝑢𝑐𝑐(𝑛)) puis la suppression de 𝑝𝑟𝑒𝑑(𝑛) (ou
𝑠𝑢𝑐𝑐(𝑛)). Ce qui donne les cas suivants:
1. Si 𝑛 est une feuille alors on l’élimine tout simplement.
2. Si 𝑛 a un seul fils alors on le remplace par son fils et on supprime son fils.
3. Si 𝑛 a deux fils alors on le remplace par 𝑝𝑟𝑒𝑑(𝑛) (ou 𝑠𝑢𝑐𝑐(𝑛)) et on supprime 𝑝𝑟𝑒𝑑(𝑛) (ou
𝑠𝑢𝑐𝑐(𝑛)).

8
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>9 de 11

Algorithmes:

Algorithme récursif:
fonction: supprimerRec(A,v).
Entrée: A un ABR et v une valeur à supprimer.
Sortie: ABR reconstruit après suppression de v de A.
Si A est non vide alors:
r ← racine(A)
Ag ← sous arbre gauche de r
Ad ← sous arbre droit de r
# Recherche de la valeur v dans A
Si v<r alors:
supprimerRec(Ag,v)
Sinon v>r alors:
supprimerRec(Ad,v)
# v trouvée:
Sinon
# 1er cas A est une feuille:
Si Ag et Ad sont vides alors:
Vider A
# 2ième cas A n'a qu'un seul fils non vide:
Sinon si Ad est vide alors:
v ← racine(Ag)
r ← v
supprimerRec(Ag,v)
Sinon si Ag est vide alors:
v ← racine(Ad)
r ← v

9
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>10 de 11

supprimerRec(Ad,v)
# 3ième cas A a 2 fils non vides:
Sinon
v ← rechercheMin(Ad)
r ← v
supprimerRec(Ad,v)

Algorithme itératif:
fonction: supprimerIt(A,v).
Entrée: A un ABR et v une valeur à supprimer.
Sortie: ABR reconstruit après suppression de v.
Tant que A est non vide faire:
r ← racine(A)
# Recherche de la valeur v dans A
Si v<r alors:
A=Ag
Sinon Si v>r alors:
A=Ad
# v trouvée:
Sinon :
# 1er cas A est une feuille:
Si Ag et Ad sont vides alors:
Vider A
# 2ième cas A n'a qu'un seul fils non vide:
Sinon si Ad est vide alors:
v ← racine(Ag)
r ← v
A ← Ag
Sinon si Ag est vide alors:
v ← racine(Ad)
r ← v
A ← Ad
# 3ième cas A a 2 fils non vides:
Sinon:
v ← rechercheMin(Ad)
r ← v
A ← Ad

2.3 3) Le tri par un ABR:

Principe On utilise les opérations 𝑖𝑠𝑒𝑟𝑡𝑖𝑜𝑛 et 𝑝𝑎𝑟𝑐𝑜𝑢𝑟𝑠𝐼𝑛𝑓𝑖𝑥𝑒 précédentes pour trier une liste 𝐿
de la façon suivante: 1. Par insertions successives d’éléments de 𝐿 dans une liste vide on construit
un ABR 𝐴. 2. Par un parcours infixé de 𝐴, on obtient la liste triée (ordre croissant) .

10
 Chap05 - Les arbres - Arbre binaire de recherche (ABR)
>11 de 11

Algorithme
fonction: triABR(L).
Entrée: L à trier.
Sortie: Une liste des éléments de L triée.
n ← Taille de L
A ← []
Pour i de 0 à (n-1) faire:
insertion(A,L[i])
Retourner parcoursInfixe(A)

2.4 4) Analyse de la complexité:

Les coûts temporels de toutes les opérations précédentes dépendent de la hauteur ℎ = ℎ(𝐴) de
l’ABR 𝐴.

2.4.1 a. Les opérations de recherche/modification:

Elles sont toutes en 𝑂(ℎ), donc:
• Si l’ ABR 𝐴 est équilibré, alors la complexité est en 𝑂(𝑙𝑜𝑔2 (𝑛)).
• Si l’ ABR 𝐴 est dégénéré, alors la complexité est en 𝑂(𝑛).

2.4.2 b. Le tri par ABR:

Soit 𝐶𝑡𝑟𝑖𝐴𝐵𝑅 (𝑛) est le coût du tri par ABR d’ordre 𝑛, on a 𝐶𝑡𝑟𝑖𝐴𝐵𝑅 (𝑛) = 𝐶𝑖𝑛𝑠 (𝑛) + 𝐶𝑝𝑎𝑟 (𝑛) où
𝐶𝑝𝑎𝑟 (𝑛) est le coût du parcours infixé et 𝐶𝑖𝑛𝑠 (𝑛) le coût des insertions successives.
1. 𝐶𝑝𝑎𝑟 (𝑛) est en 𝑂(𝑛): On visite chaque nœud au plus 2 fois.
2. Pour 𝐶𝑖𝑛𝑠 (𝑛):
• Soit ℎ la hauteur finale de 𝐴, alors le coût de chacune des 𝑛 insertions ne dépasse pas
ℎ, d’où 𝐶𝑖𝑛𝑠 (𝑛) = 𝑂(𝑛ℎ)
Le coût total est 𝐶𝑡𝑟𝑖𝐴𝐵𝑅 (𝑛) = 𝑂(𝑛ℎ)
Conclusion: La complexité du tri par ABR, selon que l’arbre construit est équilibré
ou dégénéré, est en:
• 𝑂(𝑛2 ) au pire de cas.
• 𝑂(𝑛𝑙𝑜𝑔2 (𝑛)) au meilleur de cas et au cas moyen.
• Car au cas moyen ℎ = 𝑂(𝑙𝑜𝑔2 (𝑛)).

11