corrected changes

slides/cours_16.md

@@ -891,5 +891,3 @@ booléen recherche(arbre, clé)
 3. Écrire une fonction qui insère des mots dans un arbre et ensuite affiche
    l'arbre.
 
-
-[^2]: Copyright cours de mathématiques pendant trop d'années.

slides/cours_17.md

@@ -14,6 +14,8 @@ date: "2025-03-14"
 
 # Pseudo-code d'insertion (1/4)
 
+\footnotesize
+
 * Deux parties:
     * Recherche le parent où se passe l'insertion.
     * Ajout de l'enfant dans l'arbre.
@@ -34,7 +36,7 @@ arbre position(tree, clé)
             sinon
                 suivant = droite(tree)
             
-    retourne suivant
+    retourne tree
 ```
 
 # Pseudo-code d'insertion (2/4)
@@ -159,8 +161,8 @@ node *add_key(node **tree, key_t key) {
 flowchart TB;
     10-->20;
     10-->5
-    20-->21
     20-->19
+    20-->21
 ```
 
 ::::
@@ -236,25 +238,26 @@ flowchart TB;
 
 :::
 
+# Le pseudo-code  de la suppression
 
-# Le pseudo-code de la suppression
+## Pour une feuille ou absent (ensemble)
 
-## Pour une feuille ou clé absente (ensemble)
-
-```python
-booléen suppression(tree, clé)
-    noeud = position(tree, clé)
-    si est_vide(noeud) ou clé(noeud) != clé
-        retourne faux    
-    si est_feuille(noeud)
-        noeud_parent = parent(tree, noeud)
-        si est_vide(noeud_parent) # noeud == racine
-            noeud = vide
-        sinon si gauche(noeud_parent) == noeud
-            gauche(noeud_parent) = vide
-        sinon si droite(noeud_parent) == noeud
-            droite(noeud_parent) = vide
-        retourne vrai
+```
+arbre suppression(arbre, clé)
+    sous_arbre = position(arbre, clé)
+    si est_vide(sous_arbre) ou clé(sous_arbre) != clé
+        retourne vide
+    sinon
+        si est_feuille(sous_arbre) et clé(sous_arbre) == clé
+            nouvelle_feuille = parent(arbre, sous_arbre)
+            si est_vide(nouvelle_feuille)
+                arbre = vide
+            sinon 
+                si gauche(nouvelle_feuille) == sous_arbre 
+                    gauche(nouvelle_feuille) = vide
+                sinon
+                    droite(nouvelle_feuille) = vide
+        retourne sous_arbre
 ```
 
 # Il nous manque le code pour le `parent`
@@ -264,67 +267,66 @@ booléen suppression(tree, clé)
 . . .
 
 ```
-arbre parent(tree, noeud)
-    parent = vide
-    si noeud != tree
-        actuel = tree   
-        clé = clé(noeud)
+arbre parent(arbre, sous_arbre)
+    si est_non_vide(arbre)
+        actuel = arbre
+        parent = actuel
+        clé = clé(sous_arbre)
         faire
-            parent = actuel
-            si clé < clé(actuel)
-                actuel = gauche(actuel)
-            sinon si clé > clé(actuel)
-                actuel = droite(actuel)
-        tant_que (actuel != noeud)
-    retourne parent
+            si (clé != clé(actuel))
+                parent = actuel
+                si clé < clé(actuel)
+                    actuel = gauche(actuel)
+                sinon
+                    actuel = droite(actuel)
+            sinon
+                retour parent
+        tant_que (actuel != sous_arbre)
+    retourne vide
 ```
 
-# Le pseudo-code de la suppression
+# Le pseudo-code  de la suppression
 
 \footnotesize
 
-## S'il y a un enfant à gauche (5min -> matrix)
+## Pour un seul enfant (5min -> matrix)
 
 . . .
 
-```python
-booléen suppression(tree, clé)
-    noeud = position(tree, clé)
-    subtree = position(gauche(noeud), clé)
-    val_proche = clé(subtree)
-    si est_vide(droite(noeud))
-        gauche(noeud) = gauche(subtree)
-    sinon
-        suppression(tree, val_proche)
-    clé(noeud) = val_proche
-    retourne vrai
+```
+arbre 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)
+            sinon
+                gauche(parent) = droite(sous_arbre)
+        sinon
+            si droite(parent) == sous_arbre
+                droite(parent) = gauche(sous_arbre)
+            sinon
+                gauche(parent) = gauche(sous_arbre)
+        retourne sous_arbre
 ```
 
 
-# Le pseudo-code de la suppression
+# Le pseudo-code  de la suppression
 
 \footnotesize
 
-## Bilan (ensemble)
-
-```
-booléen suppression(tree, clé)
-    noeud = position(tree, clé)
-    si est_vide(noeud) ou clé(noeud) != clé
-        retourne faux
-    si est_feuille(noeud))
-        noeud_parent = parent(tree, noeud)
-        ...
-        retourne vrai
-    si est_non_vide(gauche(noeud))
-        subtree = position(gauche(noeud), clé)
-        ...
-        retourne vrai
-    si est_non_vide(gauche(noeud))
-        subtree = position(droite(noeud), clé)
-        ...
-        retourne vrai
+## Pour au moins deux enfants (ensemble)
+
 ```
+arbre 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é)
+```
+
 
 # Exercices (poster sur matrix)