updated with insertion

slides/cours_15.md

@@ -361,7 +361,7 @@ A
 ```C
 typedef struct _node {
     contenu info;
-    struct _node *left_subtree, *right_subtree;
+    struct _node *left, *right;
 } node;
 typedef node *tree;
 ```
@@ -373,7 +373,7 @@ typedef node *tree;
 ```C
 typedef struct _node {
     int info;
-    struct _node left_subtree, right_subtree;
+    struct _node left, right;
 } node;
 ```
 
@@ -790,11 +790,11 @@ typedef struct _node {
 typedef node* tree_t;
 tree_t search(key_t key, tree_t tree) {
     tree_t current = tree;
-    while (NULL != courant && !success) {
+    while (NULL != current && !success) {
         if (current->key > X) {
-            current = courant->gauche;
+            current = current->gauche;
         } else if (current->key < X){
-            current = courant->droite;
+            current = current->droite;
         } else {
             return current;
         }
@@ -869,10 +869,10 @@ int arbre_size(tree_t tree) {
 # Pseudocode d'insertion (1/2)
 
 * Deux parties:
-    * Recherche de la position.
-    * Ajout dans l'arbre.
+    * Recherche le parent où se passe l'insertion.
+    * Ajout du fils dans l'arbre.
 
-## Recherche de la position
+## Recherche du parent
 
 ```
 arbre position(arbre, clé)
@@ -881,7 +881,7 @@ arbre position(arbre, clé)
             suivant = gauche(arbre)
         sinon
             suivant = droite(arbre)
-        tant que clé(arbre) != clé && est_non_vide(sivant)
+        tant que clé(arbre) != clé && est_non_vide(suivant)
             arbre = suivant
     returne arbre
 ```
@@ -892,23 +892,97 @@ arbre position(arbre, clé)
     * Recherche de la position.
     * Ajout dans l'arbre.
 
-## Ajout dans l'arbre
+## Ajout du fils
 
 ```
 ajout(arbre, clé)
-    si clé < clé(arbre)
-        gauche(arbre) = noeud(clé)
-    sinon si clé > clé(arbre)
-        droite(arbre) = noeud(clé)
+    si est_vide(arbre)
+        arbre = noeud(clé)
     sinon
-        retourne
+        si clé < clé(arbre)
+            gauche(arbre) = noeud(clé)
+        sinon si clé > clé(arbre)
+            droite(arbre) = noeud(clé)
+        sinon
+            retourne
 ```
 
 # Code d'insertion en C (1/2)
 
-## Recherche de la position
+## Recherche du parent (ensemble)
+
+. . .
+
+```C
+tree_t position(tree_t tree, key_t key) {
+    tree_t current = tree;
+    if (NULL != current) {
+        tree_t subtree = key > current->key ? current->right :
+        current->left;
+        while (key != current->key && NULL != subtree) {
+            current = subtree;
+        }
+    }
+    return current;
+}
+```
+
+# Code d'insertion en C (2/2)
+
+## Ajout du fils (ensemble)
+
+\scriptsize
+
+* 2 cas: arbre vide ou pas.
+* on retourne un pointeur vers le noeud ajouté (ou `NULL`)
 
+. . .
+
+```C
+tree_t add_key(tree_t *tree, key_t key) {
+    node_t *new_node = calloc(1, sizeof(*new_node)); // nouveauté!
+    new_node->key = key;
+    if (NULL == *tree) {
+        *tree = new_node;
+    } else {
+        tree_t subtree = position(*tree, key);
+        if (key == subtree->key) {
+            return NULL;
+        } else {
+            if (key > subtree->key) {
+                subtree->right = new_node;
+            } else {
+                subtree->left = new_node;
+            }
+        }
+    }
+    return new_node;
+}
+```
+
+# Une nouvelle corde à votre arc!
 
+\footnotesize
+
+```C
+void *calloc(size_t nmemb, size_t size); // man 3 calloc
+```
+
+```
+$ man 3 calloc
+
+The calloc() function allocates memory for an array of nmemb elements
+of size bytes each and returns a pointer  to  the  allocated  memory.
+The  memory is set to zero.  If nmemb or size is 0, then calloc() re‐
+turns either NULL, or a unique pointer value that can later  be  suc‐
+cessfully  passed to free().  If the multiplication of nmemb and size
+would result in integer overflow, then calloc() returns an error.  By
+contrast,  an integer overflow would not be detected in the following
+call to malloc(), with the result that an incorrectly sized block  of
+memory would be allocated:
+
+   malloc(nmemb * size);
+```
 
 
 [^1]: Copyright cours de mathématiques pendant trop d'années.