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
 
-## Pour une feuille ou clé absente (ensemble)
+## Pour une feuille ou absent (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,40 +267,48 @@ 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
+            si (clé != clé(actuel))
                 parent = actuel
                 si clé < clé(actuel)
                     actuel = gauche(actuel)
-            sinon si clé > clé(actuel)
+                sinon
                     actuel = droite(actuel)
-        tant_que (actuel != noeud)
-    retourne parent
+            sinon
+                retour parent
+        tant_que (actuel != sous_arbre)
+    retourne vide
 ```
 
 # 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)
+```
+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
-        suppression(tree, val_proche)
-    clé(noeud) = val_proche
-    retourne vrai
+            si droite(parent) == sous_arbre
+                droite(parent) = gauche(sous_arbre)
+            sinon
+                gauche(parent) = gauche(sous_arbre)
+        retourne sous_arbre
 ```
 
 
@@ -305,27 +316,18 @@ booléen suppression(tree, clé)
 
 \footnotesize
 
-## Bilan (ensemble)
+## Pour au moins deux enfants (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
+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)
 
 1. Écrire le pseudo-code de l'insertion purement en récursif.