Corrected typos in binary tree part

slides/cours_15.md

@@ -227,15 +227,15 @@ void hm_print(hm h);
 
 ## Plus sérieusement
 
-* Ensemble de **nœuds** et d'**arêtes** (graphe),
+* Ensemble de **nœuds** et d'**arêtes** (graphe).
 * Les arêtes relient les nœuds entre eux, mais pas n'importe comment: chaque
-  nœud a au plus un **parent**,
-* Le seul nœud sans parent est la **racine**,
-* Chaque nœud a un nombre fini d'**enfants**,
+  nœud a au plus un **parent**.
+* Le seul nœud sans parent est la **racine**.
+* Chaque nœud a un nombre fini d'**enfants**.
 * La hiérarchie des nœuds rend les arêtes **orientées** (parent -> enfants), et empêche les
   **cycles** (acyclique, orienté).
-* La **feuille** ou **nœud terminal** est un nœud sans enfants,
-* Le **niveau** est 1 à la racine et **niveau+1** pour les enfants,
+* La **feuille** ou **nœud terminal** est un nœud sans enfants.
+* Le **niveau** est 1 à la racine et **niveau+1** pour les enfants.
 * Le **degré** d'un nœud est le nombre de enfants du nœud.
 
 . . .
@@ -363,11 +363,11 @@ graph TD;
 
 :::
 
-* Les nœuds de degré 0, sont des feuilles.
+* Les nœuds de degré 0 sont des feuilles.
 
 # Application: recherche rapide
 
-## Pouvez vous construire un arbre pour résoudre le nombre secret?
+## Pouvez-vous construire un arbre pour résoudre le nombre secret?
 
  . . .
 
@@ -399,7 +399,7 @@ graph LR;
 
 :::
 
-# Autres représentation
+# Autres représentations
 
 * Botanique
 * **Exercice:** Ajouter les degrés/niveaux et feuilles
@@ -418,7 +418,7 @@ graph TD;
     H-->K;
 ```
 
-# Autres représentation
+# Autres représentations
 
 * Ensembliste
 
@@ -448,7 +448,7 @@ graph TD;
 
 :::
 
-# Autres représentation
+# Autres représentations
 
 * Liste
 
@@ -541,11 +541,11 @@ A
 
 # L'arbre binaire
 
-* Structure de données abstraite,
-* Chaque nœud a au plus deux enfants: gauche et droite,
-* Chaque enfants est un arbre.
+* Structure de données abstraite.
+* Chaque nœud a au plus deux enfants: gauche et droite.
+* Chaque enfant est un arbre.
 
-## Comment représenteriez vous une telle structure?
+## Comment représenteriez-vous une telle structure?
 
 . . .
 
@@ -583,7 +583,7 @@ typedef struct _node {
 
 ## Interface minimale
 
-* Qu'y mettriez vous?
+* Qu'y mettriez-vous?
 
 . . .
 
@@ -627,7 +627,7 @@ graph TD;
 
 ## Remarques
 
-* L'arbre est **hétérogène**: le genre d'info est pas le même sur chaque nœud
+* L'arbre est **hétérogène**: le genre d'info n'est pas le même sur chaque nœud
   (opérateur, opérande).
     * Les feuilles contiennent les opérandes.
     * Les nœuds internes contiennent les opérateurs.
@@ -638,14 +638,13 @@ graph TD;
 
 # Parcours d'arbres binaires
 
-* Appliquer une opération à tous les nœuds de l'arbre,
-* Nécessité de **parcourir** l'arbre,
-* Utiliser uniquement l'interface: visiter, gauche,
-  droite.
+* Appliquer une opération à tous les nœuds de l'arbre:
+    * Nécessité de **parcourir** l'arbre.
+    * Utiliser uniquement l'interface: visiter, gauche, droite
 
 ## Une idée de comment parcourir cet arbre?
 
-* 3 parcours (R: Racine, G: sous-arbre gauche, D: sous-arbre droit):
+* 3 parcours (R: racine, G: sous-arbre gauche, D: sous-arbre droit):
 
 
 ::: columns
@@ -679,16 +678,16 @@ graph TD;
 # Le parcours infixe (G, R, D)
 
 * Gauche, Racine, Droite:
-    1. On descend dans l'arbre de gauche tant qu'il est pas vide,
-    2. On visite la racine du sous arbre,
-    3. On descend dans le sous-arbre de droite (s'il est pas vide),
+    1. On descend dans l'arbre de gauche tant qu'il n'est pas vide.
+    2. On visite la racine du sous-arbre.
+    3. On descend dans le sous-arbre de droite (s'il n'est pas vide).
     4. On recommence.
 
 . . .
 
 ## Incompréhensible?
 
-* La récursivité c'est la vie.
+* La récursivité, c'est la vie.
     
 ```
 parcours_infixe(arbre a)
@@ -723,11 +722,11 @@ graph TD;
 
 ```
 parcours_infixe(arbre a)
-    si est_pas_vide(gauche(a))
-       parcours_infixe(gauche(a))
-    visiter(A)
-    si est_pas_vide(droite(A))
-       parcours_infixe(droite(A))
+   si est_pas_vide(gauche(a))
+      parcours_infixe(gauche(a))
+   visiter(A)
+   si est_pas_vide(droite(A))
+      parcours_infixe(droite(A))
 ```
 
 ::::
@@ -774,11 +773,11 @@ graph TD;
 
 ```
 parcours_infixe(arbre a)
-    si est_pas_vide(gauche(a))
-       parcours_infixe(gauche(a))
-    visiter(A)
-    si est_pas_vide(droite(A))
-       parcours_infixe(droite(A))
+   si est_pas_vide(gauche(a))
+      parcours_infixe(gauche(a))
+   visiter(A)
+   si est_pas_vide(droite(A))
+      parcours_infixe(droite(A))
 ```
 
 ## Remarque 
@@ -843,18 +842,17 @@ void tree_print(tree_t tree, int n) {
 ```
 parcours_infixe(arbre a)
     si est_pas_vide(gauche(a))
-       parcours_infixe(gauche(a))
+        parcours_infixe(gauche(a))
     visiter(A)
     si est_pas_vide(droite(A))
-       parcours_infixe(droite(A))
+        parcours_infixe(droite(A))
 ```
 
 # Correction
 
 \footnotesize
 
-* Les deux parcours sont des modifications **triviales**[^2] de l'algorithme
-  infixe.
+* Les deux parcours sont des modifications **triviales**[^2] de l'algorithme infixe.
 
 ## Le parcours postfixe
 
@@ -970,7 +968,7 @@ sous-arbres de gauche et de droite.
 
 ```python
 arbre recherche(clé, arbre)
-    tante_que est_non_vide(arbre)
+    tant_que est_non_vide(arbre)
         si clé < clé(arbre)
             arbre = gauche(arbre)
         sinon si clé > clé(arbre)
@@ -997,9 +995,9 @@ typedef node* tree_t;
 tree_t search(key_t key, tree_t tree) {
     tree_t current = tree;
     while (NULL != current) {
-        if (current->key > X) {
+        if (current->key > key) {
             current = current->gauche;
-        } else if (current->key < X){
+        } else if (current->key < key){
             current = current->droite;
         } else {
             return current;
@@ -1021,7 +1019,7 @@ qui retourne le nombre total de nœuds d'un arbre et poster le résultat sur
 matrix.
 
 Indication: la taille, est 1 + le nombre de nœuds du sous-arbre de gauche
-additionné au nombre de nœuds dans le sous-arbre de droite.
+additionné au nombre de nœuds du sous-arbre de droite.
 
 . . .
 
@@ -1031,14 +1029,14 @@ int arbre_size(tree_t tree) {
         return 0;
     } else {   
         return 1 + tree_size(tree->left) 
-            + tree_size(tree->right);
+                 + tree_size(tree->right);
     }
 }
 ```
 
 # L'insertion dans un arbre binaire
 
-* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut
+* C'est bien joli de pouvoir faire des parcours, recherches, mais si on ne peut
   pas construire l'arbre....
 
 ## Pour un arbre lexicographique
@@ -1051,9 +1049,9 @@ int arbre_size(tree_t tree) {
 * Clés uniques pour simplifier.
 * Insertion de 5, 15, 10, 25, 2, -5, 12, 14, 11.
 * Rappel:
-    * Plus petit que la clé courante => gauche,
-    * Plus grand que la clé courante => droite.
-* Faisons le dessins ensemble
+    * Plus petit que la clé courante => à gauche,
+    * Plus grand que la clé courante => à droite.
+* Faisons le dessin ensemble
 
 ```
 
@@ -1128,8 +1126,9 @@ ajout(arbre, clé)
 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;
+        tree_t subtree 
+            = key > current->key 
+                  ? current->right : current->left;
         while (key != current->key && NULL != subtree) {
             current = subtree;
             subtree = key > current->key ? current->right :