From 7ad83607809eedfd6fdcf790ffee52f7b6b3e326 Mon Sep 17 00:00:00 2001
From: "paul.albuquer" <paul.albuquerque@hesge.ch>
Date: Thu, 27 Feb 2025 21:13:28 +0100
Subject: [PATCH] Corrected typos in binary tree part
---
slides/cours_15.md | 101 ++++++++++++++++++++++-----------------------
1 file changed, 50 insertions(+), 51 deletions(-)
diff --git a/slides/cours_15.md b/slides/cours_15.md
index ce8bac2..09130b0 100644
--- a/slides/cours_15.md
+++ b/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 :
--
GitLab