diff --git a/slides/cours_17.md b/slides/cours_17.md
index d763e4d5c8afd7e52fb6f066f4e01c611fcee619..d48198fc33f8dbfdfb5ff2b555e469cb85a67ad9 100644
--- a/slides/cours_17.md
+++ b/slides/cours_17.md
@@ -21,20 +21,20 @@ date: "2025-03-14"
## Recherche du parent
```
-tree position(arbre, clé)
- si est_non_vide(arbre)
- si clé < clé(arbre)
- suivant = gauche(arbre)
+arbre position(tree, clé)
+ si est_non_vide(tree)
+ si clé < clé(tree)
+ suivant = gauche(tree)
sinon
- suivant = droite(arbre)
- tant que clé(arbre) != clé && est_non_vide(suivant)
- arbre = suivant
- si clé < clé(arbre)
- suivant = gauche(arbre)
+ suivant = droite(tree)
+ tant que clé(tree) != clé && est_non_vide(suivant)
+ tree = suivant
+ si clé < clé(tree)
+ suivant = gauche(tree)
sinon
- suivant = droite(arbre)
+ suivant = droite(tree)
- retourne arbre
+ retourne suivant
```
# Pseudo-code d'insertion (2/4)
@@ -46,14 +46,14 @@ tree position(arbre, clé)
## Ajout de l'enfant
```
-rien ajout(arbre, clé)
- si est_vide(arbre)
- arbre = nœud(clé)
+rien ajout(tree, clé)
+ si est_vide(tree)
+ tree = nœud(clé)
sinon
- si clé < clé(arbre)
- gauche(arbre) = nœud(clé)
- sinon si clé > clé(arbre)
- droite(arbre) = nœud(clé)
+ si clé < clé(tree)
+ gauche(tree) = nœud(clé)
+ sinon si clé > clé(tree)
+ droite(tree) = nœud(clé)
sinon
retourne
```
@@ -89,15 +89,15 @@ node *position(node *tree, key_t key) {
## Ajout du fils (pseudo-code)
```
-rien ajout(arbre, clé)
- si est_vide(arbre)
- arbre = nœud(clé)
+rien ajout(tree, clé)
+ si est_vide(tree)
+ tree = nœud(clé)
sinon
- arbre = position(arbre, clé)
- si clé < clé(arbre)
- gauche(arbre) = nœud(clé)
- sinon si clé > clé(arbre)
- droite(arbre) = nœud(clé)
+ tree = position(tree, clé)
+ si clé < clé(tree)
+ gauche(tree) = nœud(clé)
+ sinon si clé > clé(tree)
+ droite(tree) = nœud(clé)
sinon
retourne
```
@@ -242,21 +242,21 @@ flowchart TB;
## Pour une feuille ou absent (ensemble)
```
-tree suppression(arbre, clé)
- sous_arbre = position(arbre, clé)
- si est_vide(sous_arbre) ou clé(sous_arbre) != clé
+arbre suppression(tree, clé)
+ sub_tree = position(tree, clé)
+ si est_vide(sub_tree) ou clé(sub_tree) != clé
retourne vide
sinon
- si est_feuille(sous_arbre) et clé(sous_arbre) == clé
- nouvelle_feuille = parent(arbre, sous_arbre)
+ si est_feuille(sub_tree) et clé(sub_tree) == clé
+ nouvelle_feuille = parent(tree, sub_tree)
si est_vide(nouvelle_feuille)
arbre = vide
sinon
- si gauche(nouvelle_feuille) == sous_arbre
+ si gauche(nouvelle_feuille) == sub_tree
gauche(nouvelle_feuille) = vide
sinon
droite(nouvelle_feuille) = vide
- retourne sous_arbre
+ retourne sub_tree
```
# Il nous manque le code pour le `parent`
@@ -266,11 +266,11 @@ tree suppression(arbre, clé)
. . .
```
-tree parent(arbre, sous_arbre)
- si est_non_vide(arbre)
- actuel = arbre
+arbre parent(tree, sub_tree)
+ si est_non_vide(tree)
+ actuel = tree
parent = actuel
- clé = clé(sous_arbre)
+ clé = clé(sub_tree)
faire
si (clé != clé(actuel))
parent = actuel
@@ -280,7 +280,7 @@ tree parent(arbre, sous_arbre)
actuel = droite(actuel)
sinon
retour parent
- tant_que (actuel != sous_arbre)
+ tant_que (actuel != sub_tree)
retourne vide
```
@@ -293,21 +293,21 @@ tree parent(arbre, sous_arbre)
. . .
```
-tree suppression(arbre, clé)
- sous_arbre = position(arbre, clé)
- si est_vide(gauche(sous_arbre)) ou est_vide(droite(sous_arbre))
- parent = parent(arbre, sous_arbre)
- si est_vide(gauche(sous_arbre))
- si droite(parent) == sous_arbre
- droite(parent) = droite(sous_arbre)
+arbre suppression(tree, clé)
+ sub_tree = position(tree, clé)
+ si est_vide(gauche(sub_tree)) ou est_vide(droite(sub_tree))
+ parent = parent(tree, sub_tree)
+ si est_vide(gauche(sub_tree))
+ si droite(parent) == sub_tree
+ droite(parent) = droite(sub_tree)
sinon
- gauche(parent) = droite(sous_arbre)
+ gauche(parent) = droite(sub_tree)
sinon
- si droite(parent) == sous_arbre
- droite(parent) = gauche(sous_arbre)
+ si droite(parent) == sub_tree
+ droite(parent) = gauche(sub_tree)
sinon
- gauche(parent) = gauche(sous_arbre)
- retourne sous_arbre
+ gauche(parent) = gauche(sub_tree)
+ retourne sub_tree
```
@@ -318,12 +318,12 @@ tree suppression(arbre, clé)
## Pour au moins deux enfants (ensemble)
```
-tree suppression(arbre, clé)
- sous_arbre = position(arbre, clé) # on revérifie pas que c'est bien la clé
- si est_non_vide(gauche(sous_arbre)) et est_non_vide(droite(sous_arbre))
- max_gauche = position(gauche(sous_arbre), clé)
- échange(clé(max_gauche), clé(sous_arbre))
- suppression(gauche(sous_arbre), clé)
+arbre suppression(tree, clé)
+ sub_tree = position(tree, clé) # on ne revérifie pas que c'est bien la clé
+ si est_non_vide(gauche(sub_tree)) et est_non_vide(droite(sub_tree))
+ max_gauche = position(gauche(sub_tree), clé)
+ échange(clé(max_gauche), clé(sub_tree))
+ suppression(gauche(sub_tree), clé)
```
# Exercices (poster sur matrix)
@@ -333,15 +333,15 @@ tree suppression(arbre, clé)
. . .
```
-tree insertion(arbre, clé)
- si est_vide(arbre)
+arbre insertion(tree, clé)
+ si est_vide(tree)
retourne nœud(clé)
- si (clé < arbre->clé)
- gauche(arbre) = insert(gauche(arbre), clé)
+ si (clé < tree(clé))
+ gauche(tree) = insert(gauche(tree), clé)
sinon
- droite(arbre) = insert(droite(arbre), clé)
- retourne arbre
+ droite(tree) = insert(droite(tree), clé)
+ retourne tree
```
# Exercices (poster sur matrix)
@@ -351,15 +351,15 @@ tree insertion(arbre, clé)
. . .
```
-booléen recherche(arbre, clé)
- si est_vide(arbre)
+booléen recherche(tree, clé)
+ si est_vide(tree)
retourne faux // pas trouvée
- si clé(arbre) == clé
+ si clé(tree) == clé
retourne vrai // trouvée
- si clé < clé(arbre)
- retourne recherche(gauche(arbre), clé)
+ si clé < clé(tree)
+ retourne recherche(gauche(tree), clé)
sinon
- retourne recherche(droite(arbre), clé)
+ retourne recherche(droite(tree), clé)
```
# Exercices (Ã la maison)