diff --git a/slides/cours_16.md b/slides/cours_16.md
index 9e1aee2fc1db781b7aac42f25f2bf131bf864196..26d0da8e4d01ebb024c49c30631cedaf247aa226 100644
--- a/slides/cours_16.md
+++ b/slides/cours_16.md
@@ -277,10 +277,11 @@ arbre suppression(arbre, clé)
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))
+ parent = actuel
si clé < clé(actuel)
actuel = gauche(actuel)
sinon
@@ -324,9 +325,9 @@ arbre suppression(arbre, clé)
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(sous_arbre, clé)
+ max_gauche = position(gauche(sous_arbre), clé)
échange(clé(max_gauche), clé(sous_arbre))
- suppression(sous_arbre, clé) #
+ suppression(gauche(sous_arbre), clé)
```
# Exercices (poster sur matrix)
@@ -1195,114 +1196,3 @@ graph TD;
* Postez le résultat sur matrix.
-# L'algorithme du tri par tas (1/4)
-
-\footnotesize
-
-## Deux étapes
-
-1. Entassement (tamisage): transformer l'arbre en tas.
-2. Échanger la racine avec le dernier élément et entasser la racine.
-
-## Pseudo-code d'entassement de l'arbre (5 min, matrix)
-
-. . .
-
-```
-tri_par_tas(tab)
- entassement(tab)
- échanger(tab[0], tab[size(tab)-1])
- pour i = size(tab)-1 à 2
- promotion(tab, i)
- échanger(tab[0], tab[i-1])
-entassement(tab)
- pour i = size(tab) / 2 - 1 jusqu'à 0
- promotion(tab, i)
-promotion(tab, i)
- ind_max = ind_max(tab, i, gauche(i), droite(i))
- si i != ind_max
- échanger(tab[i], tab[ind_max])
- promotion(tab, ind_max)
-```
-
-# L'algorithme du tri par tas (2/4)
-
-* Fonctions utilitaires
-
-```
-int ind_max(tab, i, g, d)
- ind_max = i
- si tab[ind_max] < tab[l]
- ind_max = l
- si tab[ind_mx] < tab[r]
- ind_max = r
- retourne ind_max
-int gauche(i)
- retourne 2 * i + 1
-int droite(i)
- retourne 2 * i + 2
-```
-
-
-# L'algorithme du tri par tas (3/4)
-
-\footnotesize
-
-## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
-
-. . .
-
-```C
-void heapsort(int size, int tab[size]) {
- heapify(size, tab);
- swap(tab, tab + size - 1);
- for (int s = size - 1; s > 1; s--) {
- sift_up(s, tab, 0);
- swap(tab, tab + s - 1);
- }
-}
-void heapify(int size, int tab[size]) {
- for (int i = size / 2 - 1; i >= 0; i--) {
- sift_up(size, tab, i);
- }
-}
-void sift_up(int size, int tab[size], int i) {
- int ind_max = ind_max3(size, tab, i, left(i), right(i));
- if (i != ind_max) {
- swap(tab + i, tab + ind_max);
- sift_up(size, tab, ind_max);
- }
-}
-```
-
-# L'algorithme du tri par tas (3/4)
-
-\footnotesize
-
-## Fonctions utilitaires
-
-. . .
-
-```C
-int ind_max3(int size, int tab[size], int i, int l, int r) {
- int ind_max = i;
- if (l < size && tab[ind_max] < tab[l]) {
- ind_max = l;
- }
- if (r < size && tab[ind_max] < tab[r]) {
- ind_max = r;
- }
- return ind_max;
-}
-void swap(int *a, int *b) {
- int tmp = *a;
- *a = *b;
- *b = tmp;
-}
-int left(int i) {
- return 2 * i + 1;
-}
-int right(int i) {
- return 2 * i + 2;
-}
-```
diff --git a/slides/cours_17.md b/slides/cours_17.md
new file mode 100644
index 0000000000000000000000000000000000000000..404f331c2c56cc36ca075dd682c35cee99790029
--- /dev/null
+++ b/slides/cours_17.md
@@ -0,0 +1,875 @@
+---
+title: "Arbres et tri par tas"
+date: "2022-03-09"
+patat:
+ eval:
+ tai:
+ command: fish
+ fragment: false
+ replace: true
+ ccc:
+ command: fish
+ fragment: false
+ replace: true
+ images:
+ backend: auto
+---
+
+# Questions sur les notions du dernier cours
+
+* Comment représenter un tableau sous forme d'arbre binaire?
+
+. . .
+
+* Qu'est-ce qu'un tas?
+
+# Exemple de tri par tas (1/N)
+
+```
+ | 1 | 16 | 5 | 12 | 4 | 2 | 8 | 10 | 6 | 7 |
+```
+
+::: columns
+
+:::: column
+
+* Quel est l'arbre que cela représente?
+
+. . .
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((16));
+ id0-->id2((5));
+ id1-->id3((12));
+ id1-->id4((4));
+ id2-->id5((2));
+ id2-->id6((8));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((7));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* On commence à l'indice $N/2 = 5$: `7`.
+* `7 > 4` (enfant `>` parent).
+* intervertir `4` et `7`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((16));
+ id0-->id2((5));
+ id1-->id3((12));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((8));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+. . .
+
+```
+ * *
+ | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
+```
+
+# Exemple de tri par tas (2/N)
+
+```
+ | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
+```
+
+::: columns
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* On continue à l'indice $N/2-1 = 4$: `12`.
+* Déjà un tas, rien à faire.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((16));
+ id0-->id2((5));
+ id1-->id3((12));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((8));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* On continue à l'indice $N/2-2 = 3$: `5`.
+* `5 < 8`, échanger `8` et `5` (aka `max(2, 5, 8)`)
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((16));
+ id0-->id2((8));
+ id1-->id3((12));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+. . .
+
+```
+ | 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
+```
+
+# Exemple de tri par tas (3/N)
+
+```
+ | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
+```
+
+::: columns
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* Indice $N/2-1 = 4$: `12`.
+* Déjà un tas, rien à faire.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((16));
+ id0-->id2((5));
+ id1-->id3((12));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((8));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* Indice $N/2-2 = 3$: `5`.
+* `5 < 8`, `5 <=> max(2, 5, 8)`
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((16));
+ id0-->id2((8));
+ id1-->id3((12));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+```
+ * *
+ | 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
+```
+
+# Exemple de tri par tas (4/N)
+
+```
+ | 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
+```
+
+::: columns
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* Indice $N/2-3 = 1$: `16`.
+* Déjà un tas, rien à faire.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((16));
+ id0-->id2((8));
+ id1-->id3((12));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* Indice $N/2-4 = 1$: `1`.
+* `1 < 16 && 1 < 8`, `1 <=> max(1, 16, 8)`
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((16))-->id1((1));
+ id0-->id2((8));
+ id1-->id3((12));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+```
+ * *
+ | 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
+```
+
+
+# Exemple de tri par tas (5/N)
+
+```
+ | 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
+```
+
+::: columns
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* Recommencer avec `1`.
+* `1 <=> max(1, 12, 7)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((16))-->id1((12));
+ id0-->id2((8));
+ id1-->id3((1));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((10));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Transformer l'arbre en tas.
+
+* Recommencer avec `1`.
+* `1 <=> max(1, 10, 6)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((16))-->id1((12));
+ id0-->id2((8));
+ id1-->id3((10));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((1));
+ id3-->id8((6));
+ id4-->id9((4));
+ id4-->id10(( ));
+ style id10 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+```
+ * * *
+ | 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
+```
+
+* L'arbre est un tas.
+
+# Exemple de tri par tas (6/N)
+
+```
+ | 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `16` (`max` de l'arbre) avec `4`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((4))-->id1((12));
+ id0-->id2((8));
+ id1-->id3((10));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((1));
+ id3-->id8((6));
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas.
+
+* `4 <=> max(4, 12, 8)`.
+* `4 <=> max(4, 10, 7)`.
+* `4 <=> max(4, 1, 6)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((12))-->id1((10));
+ id0-->id2((8));
+ id1-->id3((6));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((1));
+ id3-->id8((4));
+```
+
+::::
+
+:::
+
+```
+ | 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
+```
+
+
+# Exemple de tri par tas (7/N)
+
+```
+ | 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `12` (`max` de l'arbre) avec `4`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((4))-->id1((10));
+ id0-->id2((8));
+ id1-->id3((6));
+ id1-->id4((7));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((1));
+ id3-->id8(( ));
+ style id8 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas.
+
+* `4 <=> max(4, 10, 8)`.
+* `4 <=> max(4, 6, 7)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((10))-->id1((7));
+ id0-->id2((8));
+ id1-->id3((6));
+ id1-->id4((4));
+ id2-->id5((2));
+ id2-->id6((5));
+ id3-->id7((1));
+ id3-->id8(( ));
+ style id8 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+```
+ | 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
+```
+
+# Exemple de tri par tas (8/N)
+
+```
+ | 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `10` (`max` de l'arbre) avec `1`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((7));
+ id0-->id2((8));
+ id1-->id3((6));
+ id1-->id4((4));
+ id2-->id5((2));
+ id2-->id6((5));
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas.
+
+* `1 <=> max(1, 7, 8)`.
+* `5 <=> max(1, 2, 5)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((8))-->id1((7));
+ id0-->id2((5));
+ id1-->id3((6));
+ id1-->id4((4));
+ id2-->id5((2));
+ id2-->id6((1));
+```
+
+::::
+
+:::
+
+```
+ | 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
+```
+
+# Exemple de tri par tas (9/N)
+
+```
+ | 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `8` (`max` de l'arbre) avec `1`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((7));
+ id0-->id2((5));
+ id1-->id3((6));
+ id1-->id4((4));
+ id2-->id5((2));
+ id2-->id6(( ));
+ style id6 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas.
+
+* `1 <=> max(1, 7, 5)`.
+* `1 <=> max(1, 6, 4)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((7))-->id1((6));
+ id0-->id2((5));
+ id1-->id3((1));
+ id1-->id4((4));
+ id2-->id5((2));
+ id2-->id6(( ));
+ style id6 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+```
+ | 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
+```
+
+# Exemple de tri par tas (10/N)
+
+```
+ | 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `7` (`max` de l'arbre) avec `2`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((2))-->id1((6));
+ id0-->id2((5));
+ id1-->id3((1));
+ id1-->id4((4));
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas.
+
+* `2 <=> max(2, 6, 5)`.
+* `2 <=> max(2, 1, 4)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((6))-->id1((4));
+ id0-->id2((5));
+ id1-->id3((1));
+ id1-->id4((2));
+```
+
+::::
+
+:::
+
+```
+ | 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
+```
+
+# Exemple de tri par tas (11/N)
+
+```
+ | 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `6` (`max` de l'arbre) avec `2`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((2))-->id1((4));
+ id0-->id2((5));
+ id1-->id3((1));
+ id1-->id4(( ));
+ style id4 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas.
+
+* `2 <=> max(2, 4, 5)`.
+* `2 <=> max(2, 1, 4)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((5))-->id1((4));
+ id0-->id2((2));
+ id1-->id3((1));
+ id1-->id4(( ));
+ style id4 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::
+
+```
+ | 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
+```
+
+# Exemple de tri par tas (12/N)
+
+```
+ | 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `5` (`max` de l'arbre) avec `1`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((1))-->id1((4));
+ id0-->id2((2));
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas.
+
+* `1 <=> max(1, 4, 2)`.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((4))-->id1((1));
+ id0-->id2((2));
+```
+
+::::
+
+:::
+
+```
+ | 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
+```
+
+# Exemple de tri par tas (13/N)
+
+```
+ | 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
+```
+
+::: columns
+
+:::: column
+
+**But:** Trier les tas.
+
+* Échanger la racine, `4` (`max` de l'arbre) avec `2`.
+* Traiter la racine.
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+ id0((2))-->id1((1));
+ id0-->id2(( ));
+ style id2 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+**But:** Trier les tas. Plus rien à trier
+
+* On fait les 2 dernières étapes en vitesse.
+* Échange `2` avec `1`.
+* Il reste que `1`. GGWP!
+
+
+::::
+
+:::
+
+```
+ | 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
+```
+
+# Exercice (10min)
+
+* Trier par tas le tableau
+
+```
+ | 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
+```
+
+* Mettez autant de détails que possible.
+* Que constatez-vous?
+* Postez le résultat sur matrix.
+
+
+# L'algorithme du tri par tas (1/4)
+
+\footnotesize
+
+## Deux étapes
+
+1. Entassement (tamisage): transformer l'arbre en tas.
+2. Échanger la racine avec le dernier élément et entasser la racine.
+
+## Pseudo-code d'entassement de l'arbre (5 min, matrix)
+
+. . .
+
+```
+tri_par_tas(tab)
+ entassement(tab)
+ échanger(tab[0], tab[size(tab)-1])
+ pour i = size(tab)-1 à 2
+ promotion(tab, i)
+ échanger(tab[0], tab[i-1])
+entassement(tab)
+ pour i = size(tab) / 2 - 1 jusqu'à 0
+ promotion(tab, i)
+promotion(tab, i)
+ ind_max = ind_max(tab, i, gauche(i), droite(i))
+ si i != ind_max
+ échanger(tab[i], tab[ind_max])
+ promotion(tab, ind_max)
+```
+
+# L'algorithme du tri par tas (2/4)
+
+* Fonctions utilitaires
+
+```
+int ind_max(tab, i, g, d)
+ ind_max = i
+ si tab[ind_max] < tab[l]
+ ind_max = l
+ si tab[ind_mx] < tab[r]
+ ind_max = r
+ retourne ind_max
+int gauche(i)
+ retourne 2 * i + 1
+int droite(i)
+ retourne 2 * i + 2
+```
+
+
+# L'algorithme du tri par tas (3/4)
+
+\footnotesize
+
+## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
+
+. . .
+
+```C
+void heapsort(int size, int tab[size]) {
+ heapify(size, tab);
+ swap(tab, tab + size - 1);
+ for (int s = size - 1; s > 1; s--) {
+ sift_up(s, tab, 0);
+ swap(tab, tab + s - 1);
+ }
+}
+void heapify(int size, int tab[size]) {
+ for (int i = size / 2 - 1; i >= 0; i--) {
+ sift_up(size, tab, i);
+ }
+}
+void sift_up(int size, int tab[size], int i) {
+ int ind_max = ind_max3(size, tab, i, left(i), right(i));
+ if (i != ind_max) {
+ swap(tab + i, tab + ind_max);
+ sift_up(size, tab, ind_max);
+ }
+}
+```
+
+# L'algorithme du tri par tas (3/4)
+
+\footnotesize
+
+## Fonctions utilitaires
+
+. . .
+
+```C
+int ind_max3(int size, int tab[size], int i, int l, int r) {
+ int ind_max = i;
+ if (l < size && tab[ind_max] < tab[l]) {
+ ind_max = l;
+ }
+ if (r < size && tab[ind_max] < tab[r]) {
+ ind_max = r;
+ }
+ return ind_max;
+}
+void swap(int *a, int *b) {
+ int tmp = *a;
+ *a = *b;
+ *b = tmp;
+}
+int left(int i) {
+ return 2 * i + 1;
+}
+int right(int i) {
+ return 2 * i + 2;
+}
+```
+