Rephrased few things arbre => tree

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)