Compare revisions

a659fffb · 4cefffd8 · cc0a0508 · b7a82223 · 86d4582e · 2b4d2e83
--- a/slides/.clang-format
+++ b/slides/.clang-format
+---
+Language:        Cpp
+# BasedOnStyle:  Google
+AccessModifierOffset: -4
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignConsecutiveMacros: true
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortLambdasOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: true
+BinPackParameters: true
+BitFieldColonSpacing: Both
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: MultiLine
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: AfterColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: AfterColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:    100
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: false
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+    SortPriority:    0
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+    SortPriority:    0
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: false
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentWidth:     4
+IndentWrappedFunctionNames: true
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Right
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+ReflowComments:  true
+SortIncludes:    false
+SortUsingDeclarations: false
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+Standard:        Auto
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        4
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+...
--- a/slides/.gitignore
+++ b/slides/.gitignore
-*.pdf
+diagram*.pdf
-*.err
+cours*.pdf
-*.markdown
+intro.pdf
-*.html
+mermaid-filter.err
-index.md
 .puppeteer.json
--- a/slides/Makefile
+++ b/slides/Makefile
@@ -18,14 +18,15 @@ all: puppeteer $(PDF)
 # all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf
 docker: docker-compose.yml
-	docker-compose run slides
+	docker compose run slides
 docker_clean: docker-compose.yml
-	docker-compose run slides clean
+	docker compose run slides clean
 puppeteer:
 	@echo "Setting chromium to $(CHROMIUM) for puppeteer"
 	@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json
+	# @echo "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json
 index.md: gen_index.sh
 	$(shell ./gen_index.sh)

--- a/slides/cours_1.md
+++ b/slides/cours_1.md
 ---
-title: "Introduction aux algorithmes"
+title: "Introduction aux algorithmes I"
-date: "2023-09-19"
+date: "2024-09-16"
 ---
 # Qu'est-ce qu'un algorithme?

--- a/slides/cours_10.md
+++ b/slides/cours_10.md
 ---
-title: "Piles"
+title: "Backtracking et piles"
-date: "2023-12-05"
+date: "2024-12-02"
 ---
-# Rappel
+# Le problème des 8-reines
-## Qu'est-ce qu'une pile?
+\Huge Le problème des 8-reines
+# Problème des 8-reines
+* Placer 8 reines sur un échiquier de $8 \times 8$.
+* Sans que les reines ne puissent se menacer mutuellement (92 solutions). 
+## Conséquence
+* Deux reines ne partagent pas la même rangée, colonne, ou diagonale.
+* Donc chaque solution a **une** reine **par colonne** ou **ligne**.
+## Généralisation
+* Placer $N$ reines sur un échiquier de $N \times
+  N$. 
+- Exemple de **backtracking** (retour en arrière) $\Rightarrow$ récursivité.
+![Problème des 8-reines. Source:
+[wikipedia](https://fr.wikipedia.org/wiki/Problème_des_huit_dames)](./figs/fig_recursivite_8_reines.png){width=35%}
+# Problème des 2-reines
+![Le problème des 2 reines n'a pas de solution.](figs/2reines.svg){width=50%}
+# Comment trouver les solutions?
+* On pose la première reine sur la première case disponible.
+* On rend inaccessibles toutes les cases menacées.
+* On pose la reine suivante sur la prochaine case non-menacée.
+* Jusqu'à ce qu'on puisse plus poser de reine.
+* On revient alors en arrière jusqu'au dernier coup où il y avait plus qu'une
+  possibilité de poser une reine.
+* On recommence depuis là.
 . . .
-* Structure de données LIFO.
+* Le jeu prend fin quand on a énuméré *toutes* les possibilités de poser les
+  reines.
+# Problème des 3-reines
+![Le problème des 3 reines n'a pas de solution non plus.](figs/3reines.svg)
+# Problème des 4-reines
+![Le problème des 4 reines a une solution.](figs/4reines.svg)
+# Problème des 4-reines, symétrie
+![Le problème des 4 reines a une autre solution (symétrie
+horizontale).](figs/4reines_sym.svg)
+# Problème des 5 reines
+## Exercice: Trouver une solution au problème des 5 reines
+* Faire une capture d'écran / une photo de votre solution et la poster sur
+  matrix.
+```C
-## Quelles fonctionnalités?
+```
+# Quelques observations sur le problème
+* Une reine par colonne au plus.
+* On place les reines sur des colonnes successives.
+* On a pas besoin de "regarder en arrière" (on place "devant" uniquement).
+* Trois étapes:
+    * On place une reine dans une case libre.
+    * On met à jour le tableau.
+    * Quand on a plus de cases libres on "revient dans le temps" ou c'est qu'on
+      a réussi.
+# Le code du problème des 8 reines (1/5)
+## Quelle structure de données?
 . . .
-1. Empiler (push): ajouter un élément sur la pile.
+Une matrice de booléens fera l'affaire:
-2. Dépiler (pop): retirer l'élément du sommet de la pile et le retrouner.
-3. Liste vide? (is_empty?).
-4. Jeter un oeil (peek): retourner l'élément du sommet de la pile (sans le dépiler).
-5. Nombre d'éléments (length).
-# Structure de données (1/2)
+```C
+bool board[n][n];
+```
-## Struct `stack`
+## Quelles fonctionnalités?
 . . .
 ```C
-#define MAX_CAPACITY 500
+// Pour chaque ligne placer la reine sur toutes les colonnes
-typedef struct _stack {
+//    et compter les solutions
-    int data[MAX_CAPACITY]; // les données
+void nbr_solutions(board, column, counter);
-    int top;                // indice du sommet
+// Copier un tableau dans un autre
-} stack;
+void copy(board_in, board_out);
+// Placer la reine à li, co et rendre inaccessible devant
+void placer_devant(board, li, co);
 ```
-# Structure de données (2/2)
+# Le code du problème des 8 reines (2/5)
-## Fonctions `stack`
+## Le calcul du nombre de solutions
-. . .
+```C
+// Calcule le nombre de solutions au problème des <n> reines
+rien nbr_solutions(board, column, count)
+    pour chaque ligne 
+        si la case libre
+            si column < n - 1
+                copier board dans un "new" board, 
+                    y poser une reine
+                    et mettre à jour ce "new" board
+                nbr_solutions(new_board, column+1, count)
+            sinon
+                on a posé la n-ème et on a gagné
+                count += 1
+```
+# Le code du problème des 8 reines (3/5)
+## Le calcul du nombre de solutions
 ```C
-void stack_init(stack *s) {
+// Placer une reine et mettre à jour
-    s->top = -1;
+rien placer_devant(board, ligne, colonne)
-}
+    board est occupé à ligne/colonne
-bool stack_is_empty(stack s) {
+        toutes les cases des colonnes
-    return s.top == -1;
+           suivantes sont mises à jour
-} 
-void stack_push(stack *s, int val) {
-    s->top += 1;
-    s->data[s->top] = val;
-}
-int stack_pop(stack *s) {
-    s->top -= 1;
-    return s->data[s->top+1];
-}
 ```
-# La pile dynamique
+# Le code du problème des 8 reines (4/5)
-## Comment modifier le code précédent pour avoir une taille dynamique?
+## Compris? Alors écrivez le code et postez le!
 . . .
+## Le nombre de solutions
+\footnotesize
 ```C
-// alloue une zone mémoire de size octets
+// Calcule le nombre de solutions au problème des <n> reines
-void *malloc(size_t size); 
+void nb_sol(int n, bool board[n][n], int co, int *ptr_cpt) {
-// change la taille allouée à size octets (contiguïté garantie)
+    for (int li = 0; li < n; li++) {
-void *realloc(void *ptr, size_t size);
+        if (board[li][co]) {
+            if (co < n-1) {
+                bool new_board[n][n]; // alloué à chaque nouvelle tentative
+                copy(n, board, new_board);         
+                prises_devant(n, new_board, li, co);
+                nb_sol(n, new_board, co+1, ptr_cpt);
+            } else {
+                *ptr_cpt = (*ptr_cpt)+1;
+            }
+        }
+    }
+}
 ```
-. . .
-**Attention:** `malloc` sert à allouer un espace mémoire (**pas** de notion de tableau).
+# Le code du problème des 8 reines (5/5)
-## Et maintenant?
+\footnotesize
-. . .
+## Placer devant
 ```C
-void stack_create(stack *s); // crée une pile avec une taille par défaut
+// Retourne une copie du tableau <board> complété avec les positions
-// vérifie si la pile est pleine et réalloue si besoin
+// prises sur la droite droite par une reine placée en <board(li,co)>
-void stack_push(stack *s, int val);
+void placer_devant(int n, bool board[n][n], int li, int co) {
-// vérifie si la pile est vide/trop grande 
+    board[li][co] = false; // position de la reine
-// et réalloue si besoin
+    for (int j = 1; j < n-co; j++) {
-void stack_pop(stack *s, int *ret); 
+        // horizontale et diagonales à droite de la reine
+        if (j <= li) {
+            board[li-j][co+j] = false;
+        }
+        board[li][co+j] = false;
+        if (li+j < n) {
+            board[li+j][co+j] = false;
+        }
+    }
+}
 ```
-. . .
+# Les piles
+\Huge Les piles
-## Faisons l'implémentation ensemble
+# Les piles (1/5)
-# Le tri à deux piles (1/3)
+## Qu'est-ce donc?
-## Cas pratique
+* Structure de données abstraite...
-![Un exemple de tri à deux piles](figs/tri_piles.svg){width=70%}
+. . .
+* de type `LIFO` (*Last in first out*).
-# Le tri à deux piles (2/3)
+![Une pile où on ajoute A, puis B avant de les retirer. Source:
+[Wikipedia](https://upload.wikimedia.org/wikipedia/commons/e/e1/Stack_(data_structure)_LIFO.svg)](figs/Stack.svg){width=70%}
-## Exercice: formaliser l'algorithme
+## Des exemples de la vraie vie
 . . .
-## Algorithme de tri nécessitant 2 piles (G, D)
+* Pile d'assiettes, de livres, ...
+* Adresses visitées par un navigateur web.
+* Les calculatrices du passé (en polonaise inverse).
+* Les boutons *undo* de vos éditeurs de texte (aka *u* dans vim).
-Soit `tab` le tableau à trier:
+# Les piles (2/5)
-```C
+## Fonctionnalités
-pour i de 0 à N-1
-    tant que (tab[i] > que le sommet de G)
-        dépiler G dans D
-    tant que (tab[i] < que le sommet de D)
-        dépiler de D dans G
-    empiler tab[i] sur G
-dépiler tout D dans G
-tab est trié dans G
-```
-# Le tri à deux piles (3/3)
+. . .
-## Exercice: trier le tableau `[2, 10, 5, 20, 15]`
+1. Empiler (push): ajouter un élément sur la pile.
+2. Dépiler (pop): retirer l'élément du sommet de la pile et le retourner.
+3. Pile vide? (is_empty?).
-```C
+. . .
+4. Jeter un œil (peek): retourner l'élément du sommet de la pile (sans le dépiler).
+5. Nombre d'éléments (length).
+## Comment faire les 4, 5 à partir de 1 à 3?
+. . .
+4. Dépiler l'élément, le copier, puis l'empiler à nouveau.
+5. Dépiler jusqu'à ce que la pile soit vide, puis empiler à nouveau.
+. . .
+## Existe en deux goûts
+* Pile avec ou sans limite de capacité (à concurrence de la taille de la
+mémoire).
+# Les piles (3/5)
+## Implémentation
+* Jusqu'ici on n'a pas du tout parlé d'implémentation (d'où le nom de structure
+  abstraite).
+* Pas de choix unique d'implémentation.
+## Quelle structure de données allons nous utiliser?
+. . .
+Et oui vous avez deviné: un tableau!
+## La structure: de quoi avons-nous besoin (pile de taille fixe)?
+. . .
+```C
+#define MAX_CAPACITY 500
+typedef struct _stack {
+    int data[MAX_CAPACITY]; // les données
+    int top;                // indice du sommet
+} stack;
 ```
-# La calculatrice (1/8)
+# Les piles (4/5)
+## Initialisation
-## Vocabulaire
+. . .
 ```C
-2 + 3 = 2 3 +,
+void stack_init(stack *s) {
+    s->top = -1;
+}
 ```
-`2` et `3` sont les *opérandes*, `+` l'*opérateur*.
+## Est vide?
 . . .
-## La notation infixe
 ```C
-2 * (3 + 2) - 4 = 6.
+bool stack_is_empty(stack s) {
+    return s.top == -1;
+} 
 ```
-## La notation postfixe
+## Empiler (ajouter un élément au sommet)
+. . .
 ```C
-2 3 2 + * 4 - = 6.
+void stack_push(stack *s, int val) {
+    s->top += 1;
+    s->data[s->top] = val;
+}
 ```
-## Exercice: écrire `2 * 3 * 4 + 2` en notation `postfixe`
+# Les piles (5/5)
+## Dépiler (enlever l'élément du sommet)
 . . .
 ```C
-2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
+int stack_pop(stack *s) {
+    s->top -= 1;
+    return s->data[s->top+1];
+}
 ```
-# La calculatrice (2/8)
+## Jeter un oeil (regarder le sommet)
-## De infixe à post-fixe
+. . .
-* Une *pile* est utilisée pour stocker *opérateurs* et *parenthèses*.
-* Les opérateurs on des *priorités* différentes.
 ```C
-^   : priorité 3
+int stack_peek(stack s) {
-* / : priorité 2
+    return s.data[s.top];
-+ - : priorité 1
+}
-( ) : priorité 0 // pas un opérateur mais bon
 ```
+## Quelle est la complexité de ces opérations?
+. . .
-# La calculatrice (3/8)
+## Voyez-vous des problèmes potentiels avec cette implémentation?
-## De infixe à post-fixe: algorithme
+. . .
-* On lit l'expression infixe de gauche à droite.
+* Empiler avec une pile pleine.
+* Dépiler avec une pile vide.
+* Jeter un oeil au sommet d'une pile vide.
-* On examine le prochain caractère de l'expression infixe.
+# Gestion d'erreur, level 0
-    * Si opérande, le placer dans l'expression du résultat.
-    * Si parenthèse le mettre dans la pile (priorité 0).
-    * Si opérateur, comparer sa priorité avec celui du sommet de la pile:
-        * Si sa priorité est plus élevée, empiler.
-        * Sinon dépiler l'opérateur de la pile dans l'expression du résultat et
-          recommencer jusqu'à apparition d'un opérateur de priorité plus faible
-          au sommet de la pile (ou pile vide).
-    * Si parenthèse fermée, dépiler les opérateurs du sommet de la pile et les
-      placer dans l'expression du résultat, jusqu'à ce qu'une parenthèse
-      ouverte apparaisse au sommet, dépiler également la parenthèse.
-    * Si il n'y a pas de caractère dans l'expression dépiler tous les
-      opérateurs dans le résultat.
-# La calculatrice (4/8)
+* Il y a plusieurs façon de traiter les erreur:
+    * Ne rien faire (laisser la responsabilité à l'utilisateur).
+    * Faire paniquer le programme (il plante plus ou moins violemment).
+    * Utiliser des codes d'erreurs.
-## De infixe à post-fixe: exemple
+## La panique
-```C
+* En C, on a les `assert()` pour faire paniquer un programme.
-Infixe              Postfixe            Pile    Priorité
-((A*B)/D-F)/(G+H)   Vide                Vide    Néant
- (A*B)/D-F)/(G+H)   Vide                (       0
-  A*B)/D-F)/(G+H)   Vide                ((      0
-   *B)/D-F)/(G+H)   A                   ((      0
-    B)/D-F)/(G+H)   A                   ((*     2
-     )/D-F)/(G+H)   AB                  ((*     2
-      /D-F)/(G+H)   AB*                 (       0
-       D-F)/(G+H)   AB*                 (/      2
-        -F)/(G+H)   AB*D                (/      2
-         F)/(G+H)   AB*D/               (-      1
-          )/(G+H)   AB*D/F              (-      1
-           /(G+H)   AB*D/F-             Vide    Néant
-```
-# La calculatrice (5/8)
+# Les assertions
-## De infixe à post-fixe: exemple
+\Huge Les assertions
+# Assertions (1/3)
 ```C
-Infixe              Postfixe            Pile    Priorité
+#include <assert.h>
-((A*B)/D-F)/(G+H)   Vide                Vide    Néant
+void assert(int expression);
--------------------------------------------------------
-           /(G+H)   AB*D/F-             Vide    Néant
-            (G+H)   AB*D/F-             /       2
-             G+H)   AB*D/F-             /(      0
-              +H)   AB*D/F-G            /(      0
-               H)   AB*D/F-G            /(+     1
-                )   AB*D/F-GH           /(+     1
-             Vide   AB*D/F-GH+          /       2
-             Vide   AB*D/F-GH+/         Vide    Néant
 ```
-# La calculatrice (6/8)
+## Qu'est-ce donc?
-\footnotesize
+- Macro permettant de tester une condition lors de l'exécution d'un programme:
+  - Si `expression == 0`{.C} (condition fausse), `assert()`{.C} affiche un message d'erreur sur `stderr`{.C} et termine l'exécution du programme.
+  - Sinon l'exécution se poursuit normalement.
+  - Peuvent être désactivés à la compilation avec `-DNDEBUG` (équivalent à `#define NDEBUG`)
-## Exercice: écrire le code et le poster sur matrix
+## À quoi ça sert?
-* Quelle est la signature de la fonction?
+- Permet de réaliser des tests unitaires.
+- Permet de tester des conditions catastrophiques d'un programme.
+- **Ne permet pas** de gérer les erreurs.
-. . .
+# Assertions (2/3)
-* Une sorte de corrigé:
+<!-- \footnotesize -->
+## Exemple
 ```C
-char *infix_to_postfix(char* infix) { // init and alloc stack and postfix
+#include <assert.h>
-    for (size_t i = 0; i < strlen(infix); ++i) {
+void stack_push(stack *s, int val) {
-        if (is_operand(infix[i])) { 
+    assert(s->top < MAX_CAPACITY-1);
-            // we just add operands in the new postfix string
+    s->top += 1;
-        } else if (infix[i] == '(') { 
+    s->data[s->top] = val;
-            // we push opening parenthesis into the stack
-        } else if (infix[i] == ')') { 
-            // we pop everything into the postfix
-        } else if (is_operator(infix[i])) {
-            // this is an operator. We add it to the postfix based 
-            // on the priority of what is already in the stack and push it
 }
+int stack_pop(stack *s) {
+    assert(s->top >= 0);
+    s->top -= 1;
+    return s->data[s->top+1];
 }
-    // pop all the operators from the s at the end of postfix
+int stack_peek(stack *s) {
-    // and end the postfix with `\0`
+    assert(s->top >= 0);
-    return postfix;
+    return s->data[s->top];
 }
 ```
+# Assertions (3/3)
-# La calculatrice (7/8)
+## Cas typiques d'utilisation
-## Évaluation d'expression postfixe: algorithme
+- Vérification de la validité des pointeurs (typiquement `!= NULL`{.C}).
+- Vérification du domaine des indices (dépassement de tableau).
-* Chaque *opérateur* porte sur les deux opérandes qui le précèdent.
+## Bug vs. erreur de *runtime*
-* Le *résultat d'une opération* est un nouvel *opérande* qui est remis au
-  sommet de la pile.
-## Exemple
+- Les assertions sont là pour détecter les bugs (erreurs d'implémentation).
+- Les assertions ne sont pas là pour gérer les problèmes externes au programme (allocation mémoire qui échoue, mauvais paramètre d'entrée passé par l'utilisateur, ...).
+. . .
+- Mais peuvent être pratiques quand même pour ça...
+- Typiquement désactivées dans le code de production.
-```C
-2 3 4 + * 5 - = ?
-```
-* On parcours de gauche à droite:
+# La pile dynamique
+## Comment modifier le code précédent pour avoir une taille dynamique?
+. . .
 ```C
-Caractère lu        Pile opérandes
+// alloue une zone mémoire de size octets
-    2               2
+void *malloc(size_t size); 
-    3               2, 3
+// change la taille allouée à size octets (contiguïté garantie)
-    4               2, 3, 4
+void *realloc(void *ptr, size_t size);
-    +               2, (3 + 4)
-    *               2 * 7
-    5               14, 5
-    -               14 - 5 = 9
 ```
-# La calculatrice (8/8)
+. . .
-## Évaluation d'expression postfixe: algorithme
-1. La valeur d'un opérande est *toujours* empilée.
+**Attention:** `malloc` sert à allouer un espace mémoire (**pas** de notion de tableau).
-2. L'opérateur s'applique *toujours* au 2 opérandes au sommet.
-3. Le résultat est remis au sommet.
-## Exercice: écrire l'algorithme en C (et poster sur matrix)
+## Et maintenant?
 . . .
 ```C
-bool evaluate(char *postfix, double *val) { // init stack
+void stack_create(stack *s); // crée une pile avec une taille par défaut
-    for (size_t i = 0; i < strlen(postfix); ++i) {
+// vérifie si la pile est pleine et réalloue si besoin
-        if (is_operand(postfix[i])) {
+void stack_push(stack *s, int val);
-            stack_push(&s, postfix[i]);
+// vérifie si la pile est vide/trop grande 
-        } else if (is_operator(postfix[i])) {
+// et réalloue si besoin
-            double rhs = stack_pop(&s);
+void stack_pop(stack *s, int *ret); 
-            double lhs = stack_pop(&s);
-            stack_push(&s, op(postfix[i], lhs, rhs));
-        }    
-    }
-    return stack_pop(&s);
-}
 ```
+. . .
+## Faisons s'implémentation ensemble
--- a/slides/cours_11.md
+++ b/slides/cours_11.md
 ---
-title: "Calculatrices, liste chaînée, et files d'attente"
+title: "Applications des piles, listes chaînées et files d'attente"
-date: "2023-12-12"
+date: "2024-12-09"
 ---
-# La calculatrice (Rappel)
+# Rappel: les piles
-## Écrire `2 * 3 * 4 + 2` en notation `postfixe`
+## Qu'est-ce donc?
 . . .
+* Structure de données abstraite de type LIFO
+## Quelles fonctionnalités?
+. . .
+1. Empiler (push): ajouter un élément sur la pile.
+2. Dépiler (pop): retirer l'élément du sommet de la pile et le retourner.
+3. Pile vide? (is_empty?).
+# Le tri à deux piles
+\Huge Le tri à deux piles
+# Le tri à deux piles (1/3)
+## Cas pratique
+![Un exemple de tri à deux piles](figs/tri_piles.svg){width=70%}
+# Le tri à deux piles (2/3)
+## Exercice: formaliser l'algorithme
+. . .
+## Algorithme de tri nécessitant 2 piles (G, D)
+Soit `tab` le tableau à trier:
 ```C
-2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
+pour i de 0 à N-1
+    tant que (tab[i] > que le sommet de G)
+        dépiler G dans D
+    tant que (tab[i] < que le sommet de D)
+        dépiler de D dans G
+    empiler tab[i] sur G
+dépiler tout D dans G
+dépiler tout G dans tab
+```
+# Le tri à deux piles (3/3)
+## Exercice: trier le tableau `[2, 10, 5, 20, 15]`
+```C
+```
+# La Calculatrice
+\Huge La Calculatrice
+# La calculatrice (1/8)
+## Vocabulaire
+```C
+2 + 3 = 2 3 +,
+```
+`2` et `3` sont les *opérandes*, `+` l'*opérateur*.
+. . .
+## La notation infixe
+```C
+2 * (3 + 2) - 4 = 6.
+```
+## La notation postfixe
+```C
+2 3 2 + * 4 - = 6.
 ```
-## Quelle structure de données utiliser pour la calculatrice?
+## Exercice: écrire `2 * 3 * 4 + 2` en notation `postfixe`
 . . .
-La pile!
+```C
+2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
+```
+# La calculatrice (2/8)
+## De infixe à post-fixe
+* Une *pile* est utilisée pour stocker *opérateurs* et *parenthèses*.
+* Les opérateurs ont des *priorités* différentes.
+```C
+^   : priorité 3
+* / : priorité 2
+ - : priorité 1
+( ) : priorité 0 // pas un opérateur mais bon
+```
+# La calculatrice (3/8)
+## De infixe à post-fixe: algorithme
+* On lit l'expression infixe de gauche à droite.
+* On examine le prochain caractère de l'expression infixe:
+    * Si opérande, le placer dans l'expression du résultat.
+    * Si parenthèse le mettre dans la pile (priorité 0).
+    * Si opérateur, comparer sa priorité avec celui du sommet de la pile:
+        * Si sa priorité est plus élevée, empiler.
+        * Sinon dépiler l'opérateur de la pile dans l'expression du résultat et
+          recommencer jusqu'à apparition d'un opérateur de priorité plus faible
+          au sommet de la pile (ou pile vide).
+    * Si parenthèse fermée, dépiler les opérateurs du sommet de la pile et les
+      placer dans l'expression du résultat, jusqu'à ce qu'une parenthèse
+      ouverte apparaisse au sommet, dépiler également la parenthèse.
+    * Si il n'y a pas de caractère dans l'expression dépiler tous les
+      opérateurs dans le résultat.
+# La calculatrice (4/8)
+## De infixe à post-fixe: exemple
-# La calculatrice (Rappel 2)
+```C
+Infixe              Postfixe            Pile    Priorité
+((A*B)/D-F)/(G+H)   Vide                Vide    Néant
+ (A*B)/D-F)/(G+H)   Vide                (       0
+  A*B)/D-F)/(G+H)   Vide                ((      0
+   *B)/D-F)/(G+H)   A                   ((      0
+    B)/D-F)/(G+H)   A                   ((*     2
+     )/D-F)/(G+H)   AB                  ((*     2
+      /D-F)/(G+H)   AB*                 (       0
+       D-F)/(G+H)   AB*                 (/      2
+        -F)/(G+H)   AB*D                (/      2
+         F)/(G+H)   AB*D/               (-      1
+          )/(G+H)   AB*D/F              (-      1
+           /(G+H)   AB*D/F-             Vide    Néant
+```
+# La calculatrice (5/8)
+## De infixe à post-fixe: exemple
+```C
+Infixe              Postfixe            Pile    Priorité
+((A*B)/D-F)/(G+H)   Vide                Vide    Néant
+--------------------------------------------------------
+           /(G+H)   AB*D/F-             Vide    Néant
+            (G+H)   AB*D/F-             /       2
+             G+H)   AB*D/F-             /(      0
+              +H)   AB*D/F-G            /(      0
+               H)   AB*D/F-G            /(+     1
+                )   AB*D/F-GH           /(+     1
+             Vide   AB*D/F-GH+          /       2
+             Vide   AB*D/F-GH+/         Vide    Néant
+```
+# La calculatrice (6/8)
 \footnotesize
-## Quel est l'algorithme pour `infix_to_postfix`?
+## Exercice: écrire le code et le poster sur matrix
+* Quelle est la signature de la fonction?
 . . .
+* Une sorte de corrigé:
 ```C
 char* infix_to_postfix(char* infix) { // init and alloc stack and postfix
    for (size_t i = 0; i < strlen(infix); ++i) {
@@ -48,7 +215,7 @@ char *infix_to_postfix(char* infix) { // init and alloc stack and postfix
 ```
-# La calculatrice (nouveautés)
+# La calculatrice (7/8)
 ## Évaluation d'expression postfixe: algorithme
@@ -75,7 +242,7 @@ Caractère lu        Pile opérandes
    -               14 - 5 = 9
 ```
-# La calculatrice (nouveautés 2)
+# La calculatrice (8/8)
 ## Évaluation d'expression postfixe: algorithme
@@ -88,7 +255,8 @@ Caractère lu        Pile opérandes
 . . .
 ```C
-double evaluate(char *postfix) { // init stack
+double evaluate(char* postfix) { 
+    // declare and initialize stack s
    for (size_t i = 0; i < strlen(postfix); ++i) {
        if (is_operand(postfix[i])) {
            stack_push(&s, postfix[i]);
@@ -102,7 +270,9 @@ double evaluate(char *postfix) { // init stack
 }
 ```
+# Liste chaînée et pile
+\Huge Liste chaînée et pile
 # La liste chaînée et pile (1/6)
@@ -124,7 +294,9 @@ typedef struct _element {
    int data;
    struct _element *next;
 } element;
-typedef element* stack;
+typedef struct _stack {
+    element *top;
+} stack;
 ```
 ## Fonctionnalités?
@@ -132,12 +304,12 @@ typedef element* stack;
 . . .
 ```C
-void stack_create(stack *s); // *s = NULL;
+void stack_create(stack *s); // s->top = NULL;
 void stack_destroy(stack *s);
 void stack_push(stack *s, int val);
 void stack_pop(stack *s, int *val);
 void stack_peek(stack s, int *val);
-bool stack_is_empty(stack s); // reutrn NULL == stack;
+bool stack_is_empty(stack s); // return NULL == s.top;
 ```
 # La liste chaînée et pile (3/6)
@@ -164,8 +336,8 @@ bool stack_is_empty(stack s); // reutrn NULL == stack;
 void stack_push(stack *s, int val) {
    element *elem = malloc(sizeof(*elem));
    elem->data = val;
-    elem->next = *s;
+    elem->next = s->top;
-    *s = elem;
+    s->top = elem;
 }
 ```
@@ -191,7 +363,7 @@ void stack_push(stack *s, int val) {
 ```C
 void stack_peek(stack s, int *val) {
-    *val = s->data;
+    *val = s.top->val;
 }
 ```
@@ -218,8 +390,8 @@ void stack_peek(stack s, int *val) {
 ```C
 void stack_pop(stack *s, int *val) {
    stack_peek(*s, val);
-    element *tmp = *s;
+    element *tmp = s->top;
-    *s = (*s)->next;
+    s->top = s->top->next;
    free(tmp);
 }
 ```
@@ -253,513 +425,3 @@ void stack_destroy(stack *s) {
 }
 ```
-# La file d'attente (1/N)
-* Structure de données abstraite permettant le stockage d'éléments.
-* *FIFO*: First In First Out, ou première entrée première sortie.
-* Analogue de la vie "réelle"":
-    * File à un guichet,
-    * Serveur d'impressions,
-    * Mémoire tampon, ...
-## Fonctionnalités
- . . .
-* Enfiler: ajouter un élément à la fin de la file.
-* Défiler: extraire un élément au devant de la file.
-* Tester si la file est vide.
-. . .
-* Lire l'élément de la fin de la file.
-* Lire l'élément du devant de la file.
-* Créer une liste vide.
-* Détruire une liste vide.
-# La file d'attente (2/N)
-\footnotesize
-## Implémentation possible
-* La structure file, contient un pointeur vers la tête et un vers le début de la file.
-* Entre les deux, les éléments sont stockés dans une liste chaînée.
-![Illustration d'une file d'attente.](figs/fig_queue_representation.png){width=80%}
-## Structure de données en C?
-. . .
-```C
-typedef struct _element {  // Elément de liste
-   int data;
-   struct _element* next;
-} element;
-typedef struct _queue {    // File d'attente:
-   element* head;  //    tête de file d'attente
-   element* tail;  //    queue de file d'attente
-} queue;
-```
-# Fonctionnalités d'une file d'attente
-## Creation et consultations
-. . .
-```C
-void queue_init(queue *fa); // head = tail = NULL
-bool queue_is_empty(queue fa); // fa.head == fa.tail == NULL
-int queue_tail(queue fa); // return fa.tail->data
-int queue_head(queue fa); // return fa.head->data
-```
-## Manipulations et destruction
-. . .
-```C
-void queue_enqueue(queue *fa, int val);
-// adds an element before the tail
-int queue_dequeue(queue *fa);
-// removes the head and returns stored value
-void queue_destroy(queue *fa);
-// dequeues everything into oblivion
-```
-# Enfilage
-## Deux cas différents:
-1. La file est vide (faire un dessin):
-. . .
-![Insertion dans une file d'attente vide.](./figs/fig_empty_queue_insert.png){width=40%}
-2. La file n'est pas vide (faire un dessin):
-. . .
-![Insertion dans une file d'attente non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}
-# Enfilage
-## Live (implémentation)
-. . .
-```C
-void queue_enqueue(queue *fa, int val) {
-    element* elmt = malloc(sizeof(*elmt));
-    elmt->data = val;
-    elmt->next = NULL;
-    if (queue_is_empty(*fa)) {
-        fa->head = elmt;
-        fa->tail = elmt;
-    } else {
-        fa->tail->next = elmt;
-        fa->tail = elmt;
-    }
-}
-```
-# Défilage
-## Trois cas différents
-1. La file a plus d'un élément (faire un dessin):
-. . .
-![Extraction d'une file d'attente](./figs/fig_queue_extract.png){width=80%}
-2. La file un seul élément (faire un dessin):
-. . .
-![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}
-3. La file est vide (problème)
-# Défilage
-## Live (implémentation)
-. . .
-```C
-int queue_dequeue(queue *fa) {
-    element* elmt = fa->head;
-    int val = elmt->data;
-    fa->head = fa->head->next;
-    free(elmt);
-    if (NULL == fa->head) {
-        fa->tail = NULL;
-    }
-    return val;
-}
-```
-. . .
-## Problème avec cette implémentation?
-# Destruction
-## Comment on faire la désallocation?
-. . .
-On défile jusqu'à ce que la file soit vide!
-# Complexité
-## Quelle sont les complexité de:
-* Enfiler?
-. . .
-* Défiler?
-. . .
-* Détruire?
-. . .
-* Est vide?
-# Implémentation alternative
-## Comment implémenter la file autrement?
-. . .
-* Données stockées dans un tableau;
-* Tableau de taille connue à la compilation ou pas (réallouable);
-* `tail` seraient les indices du tableau;
-* `capacity` seraient la capacité maximale;
-* On *enfile* "au bout" du tableau, au défile au début (indice `0`).
-. . .
-## Structure de données
-```C
-typedef struct _queue {
-    int *data;
-    int tail, capacity;
-} queue;
-```
-# File basée sur un tableau
-* Initialisation?
-. . .
-```C
-```
-* Est vide?
-. . .
-```C
-```
-* Enfiler?
-. . .
-```C
-```
-* Défiler?
-. . .
-```C
-```
-# Complexité
-## Quelle sont les complexités de:
-* Initialisation?
-. . .
-```C
-```
-* Est vide?
-. . .
-```C
-```
-* Enfiler?
-. . .
-```C
-```
-* Défiler?
-. . .
-```C
-```
-# Une file plus efficace
-## Comment faire une file plus efficace?
-* Où est-ce que ça coince?
-. . .
-* Défiler est particulièrement lent $\mathcal{O}(N)$.
-## Solution?
-. . .
-* Utiliser un indice séparé pour `head`.
-```C
-typedef struct _queue {
-    int *data;
-    int head, tail, capacity;
-} queue;
-```
-# Une file plus efficace (implémentation)
-## Enfilage
-\footnotesize
-```C
-void queue_enqueue(queue *fa, int val) {
-    if ((fa->head == 0 && fa->tail == fa->capacity-1) ||
-            (fa->tail == (fa->head-1) % (fa->capacity-1))) {
-        return; // queue is full
-    }
-    if (fa->head == -1) { // queue was empty
-        fa->head = fa->tail = 0;
-        fa->data[fa->tail] = val;
-    } else if (fa->tail == fa->capacity-1 && fa->head != 0) {
-        // the tail reached the end of the array
-        fa->tail = 0;
-        fa->data[fa->tail] = val;
-    } else {
-        // nothing particular
-        fa->tail += 1;
-        fa->data[fa->tail] = val;
-    }
-}
-```
-# Une file plus efficace (implémentation)
-## Défilage
-```C
-void queue_dequeue(queue *fa, int *val) {
-    if (queue_is_empty(*fa)) {
-        return; // queue is empty
-    }
-    *val = fa->data[fa->head];
-    if (fa->head == fa->tail) { // that was the last element
-        fa->head = fa->tail = -1;
-    } else if (fa->head == fa->capacity-1) {
-        fa->head = 0;
-    } else {
-        fa->head += 1;
-    }
-}
-```
-# Les listes triées
-Une liste chaînée triée est:
-* une liste chaînée
-* dont les éléments sont insérés dans l'ordre.
-![Exemple de liste triée.](./figs/sorted_list_example.svg)
-. . .
-* L'insertion est faite telle que l'ordre est maintenu.
-## Quelle structure de données?
-```C
-```
-# Les listes triées
-## Quel but?
-* Permet de retrouver rapidement un élément.
-* Utile pour la recherche de plus court chemin dans des graphes.
-* Ordonnancement de processus par degré de priorité.
-## Comment?
-* Les implémentations les plus efficaces se basent sur les tableaux.
-* Possibles aussi avec des listes chaînées.
-# Les listes triées
-\footnotesize
-## Quelle structure de données dans notre cas?
-Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
-```C
-typedef struct _element { // chaque élément
-    int data;
-    struct _element *next;
-} element;
-typedef element* sorted_list; // la liste
-```
-## Fonctionnalités
-```C
-// insertion de val
-sorted_list sorted_list_push(sorted_list list, int val);
-// la liste est-elle vide?
-bool is_empty(sorted_list list); // list == NULL
-// extraction de val (il disparaît)
-sorted_list sorted_list_extract(sorted_list list, int val); 
- // rechercher un élément et le retourner
-element* sorted_list_search(sorted_list list, int val);
-```
-# L'insertion
-## Trois cas
-1. La liste est vide.
-. . .
-![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}
-. . .
-```C
-sorted_list sorted_list_push(sorted_list list, int val) {
-    if (sorted_list_is_empty(list)) {
-        list = malloc(sizeof(*list));
-        list->data = val;
-        list->next = NULL;
-        return list;
-    }
-}
-```
-# L'insertion
-2. L'insertion se fait en première position.
-. . .
-![Insertion en tête de liste, `list->data >=
-val`.](figs/sorted_list_insert_first.svg){width=80%}
-. . .
-```C
-sorted_list sorted_list_push(sorted_list list, int val) {
-    if (list->data >= val) {
-        element *tmp = malloc(sizeof(*tmp));
-        tmp->data = val;
-        tmp->next = list;
-        list = tmp;
-        return list;
-    }
-}
-```
-# L'insertion
-3. L'insertion se fait sur une autre position que la première.
-. . .
-![Insertion sur une autre position, list->data <
-val.](figs/sorted_list_insert_any.svg){width=70%}
-. . .
-\footnotesize
-```C
-sorted_list sorted_list_push(sorted_list list, int val) {
-    element *tmp = malloc(sizeof(*tmp));
-    tmp->data = val;
-    element *crt = list;
-    while (NULL != crt->next && val > crt->next->data) {
-        crt = crt->next;
-    }
-    tmp->next = crt->next;
-    crt->next = tmp;
-    return list;
-}
-```
--- a/slides/cours_12.md
+++ b/slides/cours_12.md
 ---
-title: "Files d'attente, listes triées, et listes doublement chaînées"
+title: "File d'attente, liste triée, liste doublement chaînée"
-date: "2023-12-19"
+date: "2024-12-16"
 ---
-# La file d'attente (1/N)
+# La file d'attente
+\Huge La file d'attente
+# La file d'attente (1/2)
 * Structure de données abstraite permettant le stockage d'éléments.
 * *FIFO*: First In First Out, ou première entrée première sortie.
@@ -24,16 +28,16 @@ date: "2023-12-19"
 * Lire l'élément de la fin de la file.
 * Lire l'élément du devant de la file.
-* Créer une liste vide.
+* Créer une file vide.
-* Détruire une liste.
+* Détruire une file.
-# La file d'attente (2/N)
+# La file d'attente (2/2)
 \footnotesize
 ## Implémentation possible
-* La structure file, contient un pointeur vers la tête et un vers le début de la file.
+* La structure de file, contient un pointeur vers la tête et un autre vers le début de la file.
 * Entre les deux, les éléments sont stockés dans une liste chaînée.
 ![Illustration d'une file d'attente.](figs/fig_queue_representation.png){width=80%}
@@ -47,7 +51,7 @@ typedef struct _element {  // Elément de liste
   int data;
   struct _element* next;
 } element;
-typedef struct _queue {    // File d'attente:
+typedef struct _queue {    // File d'attente
   element* head;  //    tête de file d'attente
   element* tail;  //    queue de file d'attente
 } queue;
@@ -55,7 +59,7 @@ typedef struct _queue {    // File d'attente:
 # Fonctionnalités d'une file d'attente
-## Creation et consultations
+## Création et consultations
 . . .
@@ -81,7 +85,7 @@ void queue_destroy(queue *fa);
 # Enfilage
-## Deux cas différents:
+## Deux cas différents
 1. La file est vide (faire un dessin):
@@ -108,16 +112,17 @@ void queue_enqueue(queue *fa, int val) {
    elmt->next = NULL;
    if (queue_is_empty(*fa)) {
        fa->head = elmt;
+        fa->tail = elmt;
    } else {
        fa->tail->next = elmt;
-    }
        fa->tail = elmt;
    }
+}
 ```
 # Défilage
-## Deux cas différents
+## Trois cas différents
 1. La file a plus d'un élément (faire un dessin):
@@ -131,7 +136,6 @@ void queue_enqueue(queue *fa, int val) {
 ![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}
 3. La file est vide (problème)
 # Défilage
@@ -167,7 +171,7 @@ On défile jusqu'à ce que la file soit vide!
 # Complexité
-## Quelle sont les complexité de:
+## Quelle est la complexité de
 * Enfiler?
@@ -191,8 +195,8 @@ On défile jusqu'à ce que la file soit vide!
 * Données stockées dans un tableau;
 * Tableau de taille connue à la compilation ou pas (réallouable);
-* `tail` seraient les indices du tableau;
+* `tail` serait un indice du tableau;
-* `capacity` seraient la capacité maximale;
+* `capacity` serait la capacité maximale;
 * On *enfile* "au bout" du tableau, au défile au début (indice `0`).
 . . .
@@ -230,7 +234,6 @@ typedef struct _queue {
 ```
 * Enfiler?
 . . .
@@ -255,7 +258,7 @@ typedef struct _queue {
 # Complexité
-## Quelle sont les complexités de:
+## Quelle est les complexités de
 * Initialisation?
@@ -276,7 +279,6 @@ typedef struct _queue {
 ```
 * Enfiler?
 . . .
@@ -331,7 +333,7 @@ typedef struct _queue {
 ```C
 void queue_enqueue(queue *fa, int val) {
    if ((fa->head == 0 && fa->tail == fa->capacity-1) ||
-            (fa->tail == fa->head-1)) {
+            (fa->tail == (fa->head-1) % (fa->capacity-1))) {
        return; // queue is full
    }
    if (fa->head == -1) { // queue was empty
@@ -369,6 +371,9 @@ void queue_dequeue(queue *fa, int *val) {
 }
 ```
+# Listes triées
+\Huge Les listes triées
 # Les listes triées
@@ -412,7 +417,6 @@ Une liste chaînée triée est:
 ## Quelle structure de données dans notre cas?
 Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
 ```C
@@ -429,14 +433,14 @@ typedef element* sorted_list; // la liste
 // insertion de val
 sorted_list sorted_list_push(sorted_list list, int val);
 // la liste est-elle vide?
-bool is_empty(sorted_list list); // list == NULL
+bool sorted_list_is_empty(sorted_list list); // list == NULL
 // extraction de val (il disparaît)
 sorted_list sorted_list_extract(sorted_list list, int val); 
 // rechercher un élément et le retourner
 element* sorted_list_search(sorted_list list, int val);
 ```
-# L'insertion
+# L'insertion (1/3)
 ## Trois cas
@@ -459,13 +463,14 @@ sorted_list sorted_list_push(sorted_list list, int val) {
 }
 ```
-# L'insertion
+# L'insertion (2/3)
 2. L'insertion se fait en première position.
 . . .
-![Insertion en tête de liste, `list->data >= val`.](figs/sorted_list_insert_first.svg){width=80%}
+![Insertion en tête de liste, `list->data >=
+val`.](figs/sorted_list_insert_first.svg){width=80%}
 . . .
@@ -481,7 +486,7 @@ sorted_list sorted_list_push(sorted_list list, int val) {
 }
 ```
-# L'insertion
+# L'insertion (3/3)
 3. L'insertion se fait sur une autre position que la première.
@@ -507,8 +512,7 @@ sorted_list sorted_list_push(sorted_list list, int val) {
 }
 ```
+# L'extraction (1/3)
-# L'extraction
 ## Trois cas
@@ -537,8 +541,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
 }
 ```
+# L'extraction (2/3)
-# L'extraction
 2. L'élément à extraire est le premier élément de la liste
@@ -557,7 +560,8 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
    prec = crt;
    crt = crt->next;
 }
-    if (NULL != crt && crt->data == val && prec == crt) { // glue things together
+    // glue things together
+    if (NULL != crt && crt->data == val && prec == crt) {
        list = list->next;
        free(crt);
    }
@@ -565,7 +569,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
 }
 ```
-# L'extraction
+# L'extraction (3/3)
 3. L'élément à extraire n'est **pas** dans la liste.
    * La liste est vide.
@@ -595,8 +599,6 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
 # La recherche
 ```C
 element* sorted_list_search(sorted_list list, int val);
 ```
@@ -612,7 +614,9 @@ element* sorted_list_search(sorted_list list, int val) {
    element* pos = sorted_list_position(list, val); 
    if (NULL == pos && val == list->data) {
        return list; // first element contains val
-    } else if (NULL != pos && NULL != pos->next && val == pos->next->data) {
+    } else if (NULL != pos && NULL != pos->next 
+        && val == pos->next->data) 
+    {
        return pos->next; // non-first element contains val
    } else {
        return NULL; // well... val's not here
@@ -680,7 +684,6 @@ $$
 \mathcal{O}(N).
 $$
 # Liste doublement chaînée
 ## Application: navigateur ou éditeur de texte
@@ -707,6 +710,10 @@ Pas possible.
 # Liste doublement chaînée
+\Huge Liste doublement chaînée
+# Liste doublement chaînée
 ## Exercices
 * Partir du dessin suivant et par **groupe de 5**
@@ -773,4 +780,3 @@ int dll_pop(dll *list);
 // vide la liste
 void dll_destroy(dll *list);
 ```
--- a/slides/cours_13.md
+++ b/slides/cours_13.md
 ---
-title: "Listes triées, listes doublement chaînées, et tables de hachage"
+title: "Liste triée, liste doublement chaînée"
-date: "2024-01-09"
+date: "2025-01-06"
 ---
-# Rappel
+# Les listes triées
-\Huge Listes triées
+## Quel but?
-# Rappel: liste triées (1/3)
+* Permet de retrouver rapidement un élément.
+* Utile pour la recherche de plus court chemin dans des graphes.
+* Ordonnancement de processus par degré de priorité.
-## Qu'est-ce qu'une liste triée?
+## Comment?
-. . .
+* Les implémentations les plus efficaces se basent sur les tableaux.
+* Possibles aussi avec des listes chaînées.
-* une liste,
+# Les listes triées
-* dont les éléments sont insérés dans l'ordre.
-## Structure de donnée?
+\footnotesize
-. . .
+## Quelle structure de données dans notre cas?
+Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
 ```C
 typedef struct _element { // chaque élément
@@ -28,40 +32,92 @@ typedef struct _element { // chaque élément
 typedef element* sorted_list; // la liste
 ```
-# Rappel: liste triées (2/3)
+## Fonctionnalités
-## Fonctionnalités?
-. . .
 ```C
 // insertion de val
 sorted_list sorted_list_push(sorted_list list, int val);
 // la liste est-elle vide?
-bool is_empty(sorted_list list); // list == NULL
+bool sorted_list_is_empty(sorted_list list); // list == NULL
 // extraction de val (il disparaît)
 sorted_list sorted_list_extract(sorted_list list, int val); 
 // rechercher un élément et le retourner
 element* sorted_list_search(sorted_list list, int val);
 ```
-# Rappel: liste triées (3/3)
+# L'insertion (1/3)
-## L'insertion: 3 cas
+## Trois cas
 1. La liste est vide.
 . . .
-2. L'insertion se fait "avant" le premier élément.
+![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}
+. . .
+```C
+sorted_list sorted_list_push(sorted_list list, int val) {
+    if (sorted_list_is_empty(list)) {
+        list = malloc(sizeof(*list));
+        list->data = val;
+        list->next = NULL;
+        return list;
+    }
+}
+```
+# L'insertion (2/3)
+2. L'insertion se fait en première position.
+. . .
+![Insertion en tête de liste, `list->data >=
+val`.](figs/sorted_list_insert_first.svg){width=80%}
 . . .
-3. L'insertion se fait après la tête de la liste.
+```C
+sorted_list sorted_list_push(sorted_list list, int val) {
+    if (list->data >= val) {
+        element *tmp = malloc(sizeof(*tmp));
+        tmp->data = val;
+        tmp->next = list;
+        list = tmp;
+        return list;
+    }
+}
+```
+# L'insertion (3/3)
+3. L'insertion se fait sur une autre position que la première.
 . . .
-# L'extraction
+![Insertion sur une autre position, list->data < val.](figs/sorted_list_insert_any.svg){width=70%}
+. . .
+\footnotesize
+```C
+sorted_list sorted_list_push(sorted_list list, int val) {
+    element *tmp = malloc(sizeof(*tmp));
+    tmp->data = val;
+    element *crt = list;
+    while (NULL != crt->next && val > crt->next->data) {
+        crt = crt->next;
+    }
+    tmp->next = crt->next;
+    crt->next = tmp;
+    return list;
+}
+```
+# L'extraction (1/3)
 ## Trois cas
@@ -90,8 +146,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
 }
 ```
+# L'extraction (2/3)
-# L'extraction
 2. L'élément à extraire est le premier élément de la liste
@@ -119,7 +174,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
 }
 ```
-# L'extraction
+# L'extraction (3/3)
 3. L'élément à extraire n'est **pas** dans la liste.
    * La liste est vide.
@@ -149,8 +204,6 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
 # La recherche
 ```C
 element* sorted_list_search(sorted_list list, int val);
 ```
@@ -236,7 +289,6 @@ $$
 \mathcal{O}(N).
 $$
 # Liste doublement chaînée
 ## Application: navigateur ou éditeur de texte
@@ -334,607 +386,3 @@ int dll_pop(dll *list);
 void dll_destroy(dll *list);
 ```
-# Les tables de hachage
-\Huge Les tables de hachage
-# Tableau vs Table
-## Tableau
-* Chaque élément (ou valeur) est lié à un indice (la case du tableau).
-```C 
-annuaire tab[2] = {
-    "+41 22 123 45 67", "+41 22 234 56 78", ...
-};
-tab[1] == "+41 22 123 45 67";
-```
-## Table
-* Chaque élément (ou valeur) est lié à une clé.
-```C 
-annuaire tab = {
-//  Clé   ,    Valeur
-    "Paul",    "+41 22 123 45 67",
-    "Orestis", "+41 22 234 56 78",
-};
-tab["Paul"]    == "+41 22 123 45 67";
-tab["Orestis"] == "+41 22 234 56 78";
-```
-# Table
-## Définition
-Structure de données abstraite où chaque *valeur* (ou élément) est associée à une *clé* (ou
-argument).
-On parle de paires *clé-valeur* (*key-value pairs*).
-## Donnez des exemples de telles paires
-. . .
-* Annuaire (nom-téléphone),
-* Catalogue (objet-prix),
-* Table de valeur fonctions (nombre-nombre),
-* Index (nombre-page)
-* ...
-# Table
-## Opérations principales sur les tables
-* Insertion d'élément (`insert(clé, valeur)`{.C}), insère la paire `clé-valeur`
-* Consultation (`get(clé)`{.C}), retourne la `valeur` correspondant à `clé`
-* Suppression (`remove(clé)`{.C}), supprime la paire `clé-valeur`
-## Structure de données / implémentation
-Efficacité dépend de différents paramètres:
-* taille (nombre de clé-valeurs maximal),
-* fréquence d'utilisation (insertion, consultation, suppression),
-* données triées/non-triées,
-* ...
-# Consultation séquentielle (`sequential_get`)
-## Séquentielle
-* table représentée par un (petit) tableau ou liste chaînée,
-* types: `key_t` et `value_t` quelconques, et `key_value_t`
-    ```C
-    typedef struct {
-        key_t key;
-        value_t value;
-    } key_value_t;
-    ```
-* on recherche l'existence de la clé séquentiellement dans le tableau, on
-  retourne la valeur.
-# Consultation séquentielle (`sequential_get`)
-## Implémentation? Une idée?
-. . .
-```C
-bool sequential_get(int n, key_value_t table[n], key_t key, 
-    value_t *value) 
-{
-    int pos = n - 1;
-    while (pos >= 0) {
-        if (key ==  table[pos].key) {
-            *value = table[pos].value;
-            return true;
-        }
-        pos--;
-    }
-    return false;
-}
-```
-. . .
-## Inconvénient?
-# Consultation séquentielle (`sequential_get`)
-## Exercice: implémenter la même fonction avec une liste chaînée
-Poster le résultat sur matrix.
-# Consultation dichotomique (`binary_get`)
-## Dichotomique
-* table représentée par un (petit) tableau trié par les clés,
-* types: `key_t` et `value_t` quelconques, et `key_value_t`
-* on recherche l'existence de la clé par dichotomie dans le tableau, on
-  retourne la valeur,
-* les clés possèdent la notion d'ordre (`<, >, =` sont définis).
-# Consultation dichotomique (`binary_get`)
-\footnotesize
-## Implémentation? Une idée?
-. . .
-```C
-bool binary_get1(int n, value_key_t table[n], key_t key, value_t *value) {
-    int top = n - 1, bottom = 0;
-    while (top > bottom) { 
-        int middle = (top + bottom) / 2;
-        if (key > table[middle].key) {
-            bottom  = middle+1;
-        } else {
-            top = middle;
-        }
-    }
-    if (key == table[top].key) {
-        *value = table[top].value;
-        return true;
-    } else {
-        return false;
-    }
-} 
-```
-# Consultation dichotomique (`binary_get`)
-\footnotesize
-## Autre implémentation
-```C
-bool binary_get2(int n, key_value_t table[n], key_t key, value_t *value) {
-    int top = n - 1, bottom = 0;
-    while (true) { 
-        int middle = (top + bottom) / 2;
-        if (key > table[middle].key) {
-            bottom  = middle + 1;
-        } else if (key < table[middle].key) {
-            top = middle;
-        } else {
-            *value = table[middle].value;
-            return true;
-        }
-        if (top < bottom) {
-             break;
-        }
-    }
-    return false;
-}
-```
-## Quelle est la différence avec le code précédent?
-# Transformation de clé (hashing)
-## Problématique: Numéro AVS (13 chiffres)
-* Format: 106.3123.8492.13
-    ```
-    Numéro AVS    | Nom
-    0000000000000 | -------
-    ...           | ...
-    1063123849213 | Paul
-    ...           | ...
-    3066713878328 | Orestis
-    ...           | ...
-    9999999999999 | -------
-    ```
-## Quelle est la clé? Quelle est la valeur?
-. . .
-* Clé: Numéro AVS, Valeur: Nom.
-## Nombre de clés? Nombre de citoyens? Rapport?
-. . .
-* $10^{13}$ clés, $10^7$ citoyens, $10^{-5}$ ($10^{-3}\%$ de la table est
-  occupée) $\Rightarrow$ *inefficace*.
-* Pire: $10^{13}$ entrées ne rentre pas dans la mémoire d'un
-  ordinateur.
-# Transformation de clé (hashing)
-## Problématique 2: Identificateurs d'un programme
-* Format: 8 caractères (simplification)
-    ```
-    Identificateur | Adresse
-    aaaaaaaa       | -------
-    ...            | ...
-    resultat       | 3aeff
-    compteur       | 4fedc
-    ...            | ...
-    zzzzzzzz       | -------
-    ```
-## Quelle est la clé? Quelle est la valeur?
-. . .
-* Clé: Identificateur, Valeur: Adresse.
-## Nombre de clés? Nombre d'identificateur d'un programme? Rapport?
-. . .
-* $26^{8}\sim 2\cdot 10^{11}$ clés, $2000$ identificateurs, $10^{-8}$ ($10^{-6}\%$ de la table est
-  occupée) $\Rightarrow$ *un peu inefficace*.
-# Fonctions de transformation de clé (hash functions)
-* La table est représentée avec un tableau.
-* La taille du tableau est beaucoup plus petit que le nombre de clés.
-* On produit un indice du tableau à partir d'une clé:
-$$
-h(key) = n,\quad n\in\mathbb{N}.
-$$
-En français: on transforme `key` en nombre entier qui sera l'indice dans le
-tableau correspondant à `key`.
-## La fonction de hash
-* La taille du domaine des clés est beaucoup plus grand que le domaine des
-  indices.
-* Plusieurs indices peuvent correspondre à la **même clé**:
-    * Il faut traiter les **collisions**.
-* L'ensemble des indices doit être plus petit ou égal à la taille de la table.
-## Une bonne fonction de hash
-* Distribue uniformément les clés sur l'ensemble des indices.
-# Fonctions de transformation de clés: exemples
-## Méthode par troncature
-\begin{align*}
-&h: [0,9999]\rightarrow [0,9]\\
-&h(key)=\mbox{troisième chiffre du nombre.}
-\end{align*}
-```
-Key  | Index
-0003 | 0
-1123 | 2 \
-1234 | 3  |-> collision.
-1224 | 2 / 
-1264 | 6 
-```
-## Quelle est la taille de la table?
-. . .
-C'est bien dix oui.
-# Fonctions de transformation de clés: exemples
-## Méthode par découpage
-Taille de l'index: 3 chiffres.
-```
-key = 321 991 24 ->  321
-                     991
-                    + 24
-                    ----
-                    1336 -> index = 336
-```
-## Devinez l'algorithme?
-. . .
-On part de la gauche:
-1. On découpe la clé en tranche de longueur égale à celle de l'index.
-2. On somme les nombres obtenus.
-3. On tronque à la longueur de l'index.
-# Fonctions de transformation de clés: exemples
-## Méthode multiplicative
-Taille de l'index: 2 chiffres.
-```
-key = 5486 -> key^2 = 30096196 -> index = 96
-```
-On prend le carré de la clé et on garde les chiffres du milieu du résultat.
-# Fonctions de transformation de clés: exemples
-## Méthode par division modulo
-Taille de l'index: `N` chiffres.
-```
-h(key) = key % N.
-```
-## Quelle doit être la taille de la table?
-. . .
-Oui comme vous le pensiez au moins `N`.
-# Traitement des collisions
-## La collision
-```
-key1 != key2, h(key1) == h(key2)
-```
-## Traitement (une idée?)
-. . .
-* La première clé occupe la place prévue dans le tableau.
-* La deuxième (troisième, etc.) est placée ailleurs de façon **déterministe**.
-Dans ce qui suit la taille de la table est `table_size`.
-# La méthode séquentielle
-\footnotesize
-## Comment ça marche?
-* Quand l'index est déjà occupé on regarde sur la position suivante, jusqu'à en
-  trouver une libre.
-```C
-index = h(key);
-while (table[index].state == OCCUPIED && table[index].key != key) {
-   index = (index + 1) % table_size; // attention à pas dépasser
-}
-table[index].key = key;
-table[index].state = OCCUPIED;
-```
-## Problème?
-. . .
-* Regroupement d'éléments (clustering).
-# Méthode linéaire
-\footnotesize
-## Comment ça marche?
-* Comme la méthode séquentielle mais on "saute" de `k`.
-```C
-index = h(key);
-while (table[index].state == OCCUPIED && table[index].key != key) {
-   index = (index + k) % table_size; // attention à pas dépasser
-}
-table[index].key = key;
-table[index].state = OCCUPIED;
-```
-## Quelle valeur de `k` éviter?
-. . .
-* Une valeur où  `table_size` est multiple de `k`.
-Cette méthode répartit mieux les regroupements au travers de la table.
-# Méthode du double hashing
-\footnotesize
-## Comment ça marche?
-* Comme la méthode linéaire, mais `k = h2(key)` (variable).
-```C
-index = h(key);
-while (table[index].state == OCCUPIED && table[index].key != key) {
-   index = (index + h2(k)) % table_size; // attention à pas dépasser
-}
-table[index].key = key;
-table[index].state = OCCUPIED;
-```
-## Quelle propriété doit avoir `h2`?
-## Exemple
-```C
-h2(key) = (table_size - 2) - key % (table_size -2)
-```
-# Méthode pseudo-aléatoire
-\footnotesize
-## Comment ça marche?
-* Comme la méthode linéaire mais on génère `k` pseudo-aléatoirement.
-    ```C
-    index = h(key);
-    while (table[index].state == OCCUPIED && table[index].key != key) {
-        index = (index + random_number) % table_size;
-    }
-    table[index].key = key;
-    table[index].state = OCCUPIED;
-    ```
-## Comment s'assurer qu'on va bien retrouver la bonne clé?
-. . .
-* Le germe (seed) de la séquence pseudo-aléatoire doit être le même.
-* Le germe à choisir est l'index retourné par `h(key)`.
-    ```C
-    srand(h(key));
-    while {
-        random_number = rand();
-    }
-    ```
-# Méthode quadratique
-* La fonction des indices de collision est de degré 2.
-* Soit $J_0=h(key)$, les indices de collision se construisent comme:
-    ```C 
-    J_i = J_0 + i^2 % table_size, i > 0,
-    J_0 = 100, J_1 = 101, J_2 = 104, J_3 = 109, ...
-    ```
-## Problème possible?
-. . .
-* Calculer le carré peut-être "lent".
-* En fait on peut ruser un peu.
-# Méthode quadratique
-\footnotesize
-```C 
-J_i = J_0 + i^2 % table_size, i > 0,
-J_0 = 100
-          \
-           d_0 = 1 
-          /        \
-J_1 = 101           Delta = 2
-          \        /
-           d_1 = 3
-          /        \
-J_2 = 104           Delta = 2
-          \        /
-           d_2 = 5
-          /        \
-J_3 = 109           Delta = 2
-          \        /
-           d_3 = 7
-          /        
-J_4 = 116
--------------------------------------
-J_{i+1} = J_i + d_i,
-d_{i+1} = d_i + Delta, d_0 = 1, i > 0.
-```
-# Méthode de chaînage
-## Comment ça marche?
-* Chaque index de la table contient un pointeur vers une liste chaînée
-  contenant les paires clés-valeurs.
-## Un petit dessin
-```
-```
-# Méthode de chaînage
-## Exemple
-On hash avec la fonction `h(key) = key % 11` (`key` est le numéro de la lettre
-de l'alphabet)
-```
- U  | N | E | X | E | M | P | L | E | D | E | T | A | B | L | E
- 10 | 3 | 5 | 2 | 5 | 2 | 5 | 1 | 5 | 4 | 5 | 9 | 1 | 2 | 1 | 5
-```
-## Comment on représente ça? (à vous)
-. . .
-![La méthode de chaînage](figs/fig_hash.png){width=80%}
-# Méthode de chaînage
-Avantages:
-* Si les clés sont grandes l'économie de place est importante (les places vides
-  sont `NULL`).
-* La gestion des collisions est conceptuellement simple.
-* Pas de problème de regroupement (clustering).
-# Exercice 1
-* Construire une table à partir de la liste de clés suivante:
-    ```
-    R, E, C, O, U, P, A, N, T
-    ```
-* On suppose que la table est initialement vide, de taille $n = 13$.
-* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.
-# Exercice 2
-* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter
-  les collisions avec
-\begin{align*}
-h_1(k)&=k\mod 13,\\
-h_2(k)&=1+(k\mod 11).
-\end{align*}
-* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de
-  collision.
-# Exercice 3
-* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
-tableau de 10 positions.
-* Les numéros sont compris entre 100 et 299.
-* Soit $N$ le numéro de téléphone, la fonction de hachage est
-$$
-h(N)=N\mod 10.
-$$
-* La fonction de gestion des collisions est
-$$
-C_1(N,i)=(h(N)+3\cdot i)\mod 10.
-$$
-* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
-* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
-* Rechercher 35.
-* Les cases ni supprimées, ni occupées sont vides.
-* Expliquer se qui se passe si on utilise?
-$$
-C_1(N,i)=(h(N)+5\cdot i)\mod 10.
-$$
--- a/slides/cours_14.md
+++ b/slides/cours_14.md
 ---
 title: "Tables de hachage"
-date: "2024-02-20"
+date: "2025-02-21"
 ---
 # Les tables de hachage
@@ -187,6 +187,8 @@ bool binary_get2(int n, key_value_t table[n], key_t key, value_t *value) {
 # Transformation de clé (hashing)
+\footnotesize
 ## Problématique: Numéro AVS (13 chiffres)
 * Format: 106.3123.8492.13
@@ -572,3 +574,37 @@ Avantages:
 * On suppose que la table est initialement vide, de taille $n = 13$.
 * Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.
+# Exercice 2
+* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter
+  les collisions avec
+\begin{align*}
+h_1(k)&=k\mod 13,\\
+h_2(k)&=1+(k\mod 11).
+\end{align*}
+* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de
+  collision.
+# Exercice 3
+* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
+tableau de 10 positions.
+* Les numéros sont compris entre 100 et 299.
+* Soit $N$ le numéro de téléphone, la fonction de hachage est
+$$
+h(N)=N\mod 10.
+$$
+* La fonction de gestion des collisions est
+$$
+C_1(N,i)=(h(N)+3\cdot i)\mod 10.
+$$
+* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
+* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
+* Rechercher 35.
+* Les cases ni supprimées, ni occupées sont vides.
+* Expliquer se qui se passe si on utilise?
+$$
+C_1(N,i)=(h(N)+5\cdot i)\mod 10.
+$$
--- a/slides/cours_15.md
+++ b/slides/cours_15.md
 ---
 title: "Fin des tables de hachages et arbres"
-date: "2024-02-27"
+date: "2025-02-28"
 ---
 # Rappel
@@ -14,7 +14,7 @@ date: "2024-02-27"
 . . .
-* Insetion, consultation, suppression.
+* Insertion, consultation, suppression.
    ```C
    void insert(table, key, value)
@@ -37,13 +37,12 @@ date: "2024-02-27"
 h_1(k)&=k\mod 13,\\
 h_2(k)&=1+(k\mod 11).
 \end{align*}
-* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de
+* En cas de collision, on fait un saut de $h_2(k)$, c.-à-d. $$index = (index + h_2(k)) \mod 13.$$
-  collision.
 # Exercice 3
-* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
+* Stocker les numéros de téléphones internes d'une entreprise dans un
 tableau de 10 positions.
 * Les numéros sont compris entre 100 et 299.
 * Soit $N$ le numéro de téléphone, la fonction de hachage est
@@ -52,8 +51,9 @@ h(N)=N\mod 10.
 $$
 * La fonction de gestion des collisions est
 $$
-C_1(N,i)=(h(N)+3\cdot i)\mod 10.
+C_1(N,i)=(h(N)+3\cdot i)\mod 10
 $$
+où $i$ compte les collisions.
 * Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
 * Supprimer 175 (rechercher 175, et mettre son état à supprimé).
 * Rechercher 35.
@@ -67,7 +67,7 @@ $$
 \small
-* On considère pas le cas du chaînage en cas de collisions.
+* Ici, on ne considère pas le cas du chaînage en cas de collisions.
 * L'insertion est construite avec une forme du type
    ```C
@@ -97,7 +97,8 @@ $$
 rien insertion(table, clé, valeur) {
    index = hash(clé)
    index = 
-        tant que état(table[index]) == occupé et clé(table[index]) != clé:
+        tant que état(table[index]) == occupé 
+                 et clé(table[index]) != clé:
            index = rehash(clé)
    état(table[index]) = occupé
@@ -115,7 +116,8 @@ rien insertion(table, clé, valeur) {
 valeur suppression(table, clé):
    index = hash(clé)
    tant que état(table[index]) != vide:
-        si état(table[index]) == occupé et clé(table[index]) == clé:
+        si état(table[index]) == occupé 
+                et clé(table[index]) == clé:
            état(table[index]) = supprimé
        sinon
            index = rehash(clé)
@@ -132,7 +134,8 @@ valeur suppression(table, clé):
 booléen recherche(table, clé) {
    index = hash(clé)
    tant que état(table[index]) != vide:
-        si état(table[index]) == occupé et clé(table[index]) == clé:
+        si état(table[index]) == occupé 
+                et clé(table[index]) == clé:
            retourner vrai
        sinon
            index = rehash
@@ -212,7 +215,7 @@ void hm_print(hm h);
 # Les arbres
-{\Huge Les arbres}
+\Huge Les arbres
 # Les arbres: définition
@@ -224,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**,
+  nœud a au plus un **parent**.
-* Le seul nœud sans parent est la **racine**,
+* Le seul nœud sans parent est la **racine**.
-* Chaque nœud a un nombre fini d'**enfants**,
+* 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,
+* 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 **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.
 . . .
@@ -360,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?
 . . .
@@ -396,7 +399,7 @@ graph LR;
 :::
-# Autres représentation
+# Autres représentations
 * Botanique
 * **Exercice:** Ajouter les degrés/niveaux et feuilles
@@ -415,7 +418,7 @@ graph TD;
    H-->K;
 ```
-# Autres représentation
+# Autres représentations
 * Ensembliste
@@ -445,7 +448,7 @@ graph TD;
 :::
-# Autres représentation
+# Autres représentations
 * Liste
@@ -536,605 +539,3 @@ 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.
-## Comment représenteriez vous une telle structure?
-. . .
-```C
-<R, G, D>
-    R: racine
-    G: sous-arbre gauche
-    D: sous-arbre droite
-```
-## Comment cela s'écrirait en C?
-. . .
-```C
-typedef struct _node {
-    contenu info;
-    struct _node *left, *right;
-} node;
-typedef node *tree;
-```
-# L'arbre binaire
-## Que se passerait-il avec 
-```C
-typedef struct _node {
-    int info;
-    struct _node left, right;
-} node;
-```
-* On ne sait pas quelle est la taille de node, on ne peut pas l'allouer!
-## Interface minimale
-* Qu'y mettriez vous?
-. . .
-```C 
-NULL              -> arbre (vide)
-<n, arbre, arbre> -> arbre
-visiter(arbre)    -> nœud (la racine de l'arbre)
-gauche(arbre)     -> arbre (sous-arbre de gauche)
-droite(arbre)     -> arbre (sous-arbre de droite)
-```
-* Les autres opérations (insertion, parcours, etc) dépendent de ce qu'on stocke
-  dans l'arbre.
-# Exemple d'arbre binaire
-* Représentez `(c - a * b) * (d + e / f)` à l'aide d'un arbre binaire (matrix)
-. . .
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    A[*]-->B[-];
-    B-->C[c];
-    B-->D[*];
-    D-->E[a];
-    D-->F[b];
-    A-->G[+];
-    G-->H[d];
-    G-->I["/"];
-    I-->J[e];
-    I-->K[f];
-```
-::::
-:::: column
-## Remarques
-* L'arbre est **hétérogène**: le genre d'info 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.
-::::
-:::
-# 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.
-## Une idée de comment parcourir cet arbre?
-* 3 parcours (R: Racine, G: sous-arbre gauche, D: sous-arbre droit):
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    A[*]-->B[-];
-    B-->C[c];
-    B-->D[*];
-    D-->E[a];
-    D-->F[b];
-    A-->G[+];
-    G-->H[d];
-    G-->I["/"];
-    I-->J[e];
-    I-->K[f];
-```
-::::
-:::: column
-1. Parcours **préfixe** (R, G, D),
-2. Parcours **infixe** (G, R, D),
-3. Parcours **postfixe** (G, D, R).
-::::
-:::
-# 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),
-    4. On recommence.
-. . .
-## Incompréhensible?
-* La récursivité c'est la vie.
-```
-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))
-```
-# Graphiquement (dessinons)
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    A[*]-->B[-];
-    B-->C[c];
-    B-->D[*];
-    D-->E[a];
-    D-->F[b];
-    A-->G[+];
-    G-->H[d];
-    G-->I["/"];
-    I-->J[e];
-    I-->K[f];
-```
-::::
-:::: column
-```
-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))
-```
-::::
-:::
-# Graphiquement (`mermaid` c'est super)
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    A[*]-->B[-];
-    A[*]-.->|1|B[-];
-    B-->C[c];
-    B-.->|2|C[c];
-    C-.->|3|B;
-    B-->D[*];
-    B-.->|4|D;
-    D-->E[a];
-    D-.->|5|E;
-    E-.->|6|D;
-    D-->F[b];
-    D-.->|7|F;
-    F-.->|8|A;
-    A-->G[+];
-    A-.->|9|G;
-    G-->H[d];
-    G-.->|10|H;
-    H-.->|11|G;
-    G-->I["/"];
-    G-.->|12|I;
-    I-->J[e];
-    I-.->|13|J;
-    J-.->|14|I;
-    I-->K[f];
-    I-.->|15|K;
-```
-::::
-:::: column
-```
-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))
-```
-## Remarque 
-Le nœud est visité à la **remontée**.
-## Résultat
-```
-c - a * b * d + e / f
-```
-::::
-:::
-# Et en C?
-## Live code
-\footnotesize
-. . .
-```C
-typedef int data;
-typedef struct _node {
-    data info;
-    struct _node* left;
-    struct _node* right;
-} node;
-typedef node* tree_t;
-void tree_print(tree_t tree, int n) {
-    if (NULL != tree) {
-        tree_print(tree->left, n+1);
-        for (int i = 0; i < n; i++) {
-            printf(" ");
-        }
-        printf("%d\n", tree->info);
-        tree_print(tree->right, n+1);
-    }
-}
-```
-# Question
-## Avez-vous compris le fonctionnement?
-. . .
-## Vous en êtes sûr·e·s?
-. . .
-## OK, alors deux exercices:
-1. Écrire le pseudo-code pour le parcours R, G, D (matrix).
-2. Écrire le pseudo-code pour la parcours G, D, R (matrix),
-## Rappel
-```
-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))
-```
-# Correction
-\footnotesize
-* Les deux parcours sont des modifications **triviales**[^2] de l'algorithme
-  infixe.
-## Le parcours postfixe
-```python
-parcours_postfixe(arbre a)
-    si est_pas_vide(gauche(a))
-       parcours_postfixe(gauche(a))
-    si est_pas_vide(droite(a))
-       parcours_postfixe(droite(a))
-    visiter(a)
-```
-## Le parcours préfixe
-```python
-parcours_préfixe(arbre a)
-    visiter(a)
-    si est_pas_vide(gauche(a))
-        parcours_préfixe(gauche(a))
-    si est_pas_vide(droite(a))
-        parcours_préfixe(droite(a))
-```
-. . .
-**Attention:** L'implémentation de ces fonctions en C sont **à faire** en
-exercice (inspirez vous de ce qu'on a fait avant)!
-# Exercice: parcours
-## Comment imprimer l'arbre ci-dessous?
-```
-                        f
-                /
-                        e
-        +
-                d
-*
-                c
-        -
-                        b
-                *
-                        a
-```
-. . .
-## Bravo vous avez trouvé! 
-* Il s'agissait du parcours D, R, G.
-# Implémentation
-## Vous avez 5 min pour implémenter cette fonction et la poster sur matrix!
-. . .
-```C 
-void pretty_print(tree_t tree, int n) {
-    if (NULL != tree) {
-        pretty_print(tree->right, n+1);
-        for (int i = 0; i < n; ++i) {
-            printf(" ");
-        }
-        printf("%d\n", tree->info);
-        pretty_print(tree->left, n+1);
-    }
-}
-```
-# Exercice supplémentaire (sans corrigé)
-Écrire le code de la fonction 
-```C
-int depth(tree_t t);
-```
-qui retourne la profondeur maximale d'un arbre.
-Indice: la profondeur à chaque niveau peut-être calculée à partir du niveau des
-sous-arbres de gauche et de droite.
-# La recherche dans un arbre binaire
-* Les arbres binaires peuvent retrouver une information très rapidement.
-* À quelle complexité? À quelle condition?
-. . .
-## Condition
-* Le contenu de l'arbre est **ordonné** (il y a une relation d'ordre (`<`, `>`
-  entre les éléments).
-## Complexité
-* La profondeur de l'arbre (ou le $\mathcal{O}(\log_2(N))$)
-. . .
-## Exemple: les arbres lexicographiques
-* Chaque nœud contient une information de type ordonné, la **clé**,
-* Par construction, pour chaque nœud $N$:
-    * Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.
-    * Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.
-# Algorithme de recherche
-* Retourner le nœud si la clé est trouvée dans l'arbre.
-```python
-arbre recherche(clé, arbre)
-    tante_que est_non_vide(arbre)
-        si clé < clé(arbre)
-            arbre = gauche(arbre)
-        sinon si clé > clé(arbre)
-            arbre = droite(arbre)
-        sinon
-            retourne arbre
-    retourne NULL
-```
-# Algorithme de recherche, implémentation (live)
-\footnotesize
-. . .
-```C 
-typedef int key_t;
-typedef struct _node {
-    key_t key;
-    struct _node* left;
-    struct _node* right;
-} node;
-typedef node* tree_t;
-tree_t search(key_t key, tree_t tree) {
-    tree_t current = tree;
-    while (NULL != current) {
-        if (current->key > X) {
-            current = current->gauche;
-        } else if (current->key < X){
-            current = current->droite;
-        } else {
-            return current;
-        }
-    }
-    return NULL;
-}
-```
-# Exercice (5-10min)
-Écrire le code de la fonction
-```C 
-int tree_size(tree_t tree);
-```
-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.
-. . .
-```C
-int arbre_size(tree_t tree) {
-    if (NULL == tree) {
-        return 0;
-    } else {   
-        return 1 + tree_size(tree->left) 
-            + tree_size(tree->right);
-    }
-}
-```
-# L'insertion dans un arbre binaire
-* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut
-  pas construire l'arbre....
-## Pour un arbre lexicographique
-* Rechercher la position dans l'arbre où insérer.
-* Créer un nœud avec la clé et le rattacher à l'arbre.
-# Exemple d'insertions
-* 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
-```
-```
-## Exercice (3min, puis matrix)
-* Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5 
-# Pseudo-code d'insertion (1/2)
-* Deux parties:
-    * Recherche le parent où se passe l'insertion.
-    * Ajout de l'enfant dans l'arbre.
-## Recherche du parent
-```
-arbre position(arbre, clé)
-    si est_non_vide(arbre)
-        si clé < clé(arbre)
-            suivant = gauche(arbre)
-        sinon
-            suivant = droite(arbre)
-        tant que clé(arbre) != clé && est_non_vide(suivant)
-            arbre = suivant
-            si clé < clé(arbre)
-                suivant = gauche(arbre)
-            sinon
-                suivant = droite(arbre)
-    retourne arbre
-```
-# Pseudo-code d'insertion (2/2)
-* Deux parties:
-    * Recherche de la position.
-    * Ajout dans l'arbre.
-## Ajout de l'enfant
-```
-ajout(arbre, clé)
-    si est_vide(arbre)
-        arbre = nœud(clé)
-    sinon
-        si clé < clé(arbre)
-            gauche(arbre) = nœud(clé)
-        sinon si clé > clé(arbre)
-            droite(arbre) = nœud(clé)
-        sinon
-            retourne
-```
-# Code d'insertion en C
-## 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;
-            subtree = key > current->key ? current->right :
-            current->left;
-        }
-    }
-    return current;
-}
-```
-[^2]: Copyright cours de mathématiques pendant trop d'années.
--- a/slides/cours_16.md
+++ b/slides/cours_16.md
 ---
-title: "Arbres"
+title: "Arbres binaires"
-date: "2024-03-05"
+date: "2025-03-07"
 ---
-# Les arbres
+# Les arbres binaires
-{\Huge Les arbres}
+\Huge Les arbres binaires
-# Les arbres: définition
-"Un arbre est un graphe acyclique orienté possédant une unique racine, et tel que tous les nœuds sauf la racine ont un unique parent."
-. . .
-**Santé!**
-## Plus sérieusement
-* 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**,
-* 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,
-* Le **degré** d'un nœud est le nombre de enfants du nœud.
-. . .
-* Chaque nœud est un arbre en lui même.
-* La **récursivité** sera très utile!
-# Arbre ou pas arbre?
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    1-->2;
-    1-->3;
-    3-->2;
-    3-->4;
-    3-->5;
-```
-::::
-. . .
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    1-->2;
-    1-->3;
-    3-->4;
-    3-->5;
-    3-->6;
-```
-::::
-:::
-# Arbre ou pas arbre?
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    1-->2;
-    1-->3;
-    3-->4;
-    3-->5;
-    3-->6;
-    6-->7;
-    7-->3;
-```
-::::
-. . .
-:::: column
-```{.mermaid format=pdf width=300 loc=figs/}
-graph TD;
-    1;
-```
-::::
-:::
-# Arbre ou pas arbre?
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    1---2;
-    1---3;
-    3---4;
-    3---5;
-```
-::::
-. . .
-:::: column
-```{.mermaid format=pdf width=300 loc=figs/}
-graph BT;
-    1-->2;
-    1-->3;
-    3-->4;
-    3-->5;
-    3-->6;
-```
-::::
-:::
-# Degré et niveau
-* Illustration du degré (nombre d'enfants) et du niveau (profondeur)
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    1[degré 2]-->2[degré 0];
-    1-->3[degré 3];
-    3-->4[degré 0];
-    3-->5[degré 0];
-    3-->6[degré 0];
-```
-::::
-. . .
-:::: column
-```{.mermaid format=pdf width=300 loc=figs/}
-graph TD;
-    1[niveau 1]-->2[niveau 2];
-    1-->3[niveau 2];
-    3-->4[niveau 3];
-    3-->5[niveau 3];
-    3-->6[niveau 3];
-```
-::::
-:::
-* Les nœuds de degré 0, sont des feuilles.
-# Application: recherche rapide
-## Pouvez vous construire un arbre pour résoudre le nombre secret?
- . . .
-* Le nombre secret ou la recherche dichotomique (nombre entre 0 et 10).
-::: columns
-:::: column
-```{.mermaid format=pdf width=400 loc=figs/}
-graph LR;
-    5-->|<|2;
-    5-->|>|7;
-    7-->|>|8;
-    7-->|<|6;
-    8-->|>|9;
-    9-->|>|10;
-    2-->|<|1;
-    2-->|>|3;
-    3-->|>|4;
-    1-->|<|0;
-```
-::::
-:::: column
-**Question:** Quelle est la complexité pour trouver un nombre?
-::::
-:::
-# Autres représentation
-* Botanique
-* **Exercice:** Ajouter les degrés/niveaux et feuilles
-```{.mermaid width=250 format=pdf loc=figs/}
-graph TD;
-    A-->B;
-    A-->C;
-    B-->D;
-    B-->E;
-    B-->F;
-    F-->I;
-    F-->J;
-    C-->G;
-    C-->H;
-    H-->K;
-```
-# Autres représentation
-* Ensembliste
-::: columns
-:::: column
-```{.mermaid width=300 format=pdf loc=figs/}
-graph TD;
-    A-->B;
-    A-->C;
-    B-->D;
-    B-->E;
-    B-->F;
-    F-->I;
-    F-->J;
-    C-->G;
-    C-->H;
-    H-->K;
-```
-::::
-. . .
-:::: column
-![](figs/ensemble.svg)
-::::
-:::
-# Autres représentation
-* Liste
-::: columns
-:::: column
-```{.mermaid width=400 format=pdf loc=figs/}
-graph TD;
-    A-->B;
-    A-->C;
-    B-->D;
-    B-->E;
-    B-->F;
-    F-->I;
-    F-->J;
-    C-->G;
-    C-->H;
-    H-->K;
-```
-::::
-. . .
-:::: column
-```
-(A 
-    (B 
-        (D) 
-        (E) 
-        (F 
-            (I) 
-            (J)
-        )
-    ) 
-    (C
-        (G) 
-        (H 
-            (K)
-        )
-    )
-)
-```
-::::
-:::
-# Autres représentation
-* Par niveau
-::: columns
-:::: column
-```{.mermaid width=400 format=pdf loc=figs/}
-graph TD;
-    A-->B;
-    A-->C;
-    B-->D;
-    B-->E;
-    B-->F;
-    F-->I;
-    F-->J;
-    C-->G;
-    C-->H;
-    H-->K;
-```
-::::
-. . .
-:::: column
-```
-1       2       3       4
-------------------------
-A       
-        B       
-                D 
-                E 
-                F           
-                        I
-                        J
-        C       
-                G
-                H
-                        K
-```
-::::
-:::
 # L'arbre binaire
 * Structure de données abstraite,
 * Chaque nœud a au plus deux enfants: gauche et droite,
-* Chaque enfants est un arbre.
+* Chaque enfant est un arbre.
 ## Comment représenteriez vous une telle structure?
@@ -355,11 +33,12 @@ typedef struct _node {
    contenu info;
    struct _node *left, *right;
 } node;
-typedef node *tree;
 ```
 # L'arbre binaire
+\footnotesize
 ## Que se passerait-il avec 
 ```C
@@ -369,6 +48,8 @@ typedef struct _node {
 } node;
 ```
+. . .
 * On ne sait pas quelle est la taille de node, on ne peut pas l'allouer!
 ## Interface minimale
@@ -417,7 +98,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.
@@ -469,24 +150,24 @@ 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,
+    1. On descend dans l'arbre de gauche tant qu'il n'est pas vide.
-    2. On visite la racine du sous arbre,
+    2. On visite la racine du sous arbre.
-    3. On descend dans le sous-arbre de droite (s'il est pas vide),
+    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)
   si est_pas_vide(gauche(a))
      parcours_infixe(gauche(a))
-    visiter(A)
+   visiter(a)
-    si est_pas_vide(droite(A))
+   si est_pas_vide(droite(a))
-       parcours_infixe(droite(A))
+      parcours_infixe(droite(a))
 ```
 # Graphiquement (dessinons)
@@ -515,9 +196,9 @@ graph TD;
 parcours_infixe(arbre a)
   si est_pas_vide(gauche(a))
      parcours_infixe(gauche(a))
-    visiter(A)
+   visiter(a)
-    si est_pas_vide(droite(A))
+   si est_pas_vide(droite(a))
-       parcours_infixe(droite(A))
+      parcours_infixe(droite(a))
 ```
 ::::
@@ -566,9 +247,9 @@ graph TD;
 parcours_infixe(arbre a)
   si est_pas_vide(gauche(a))
      parcours_infixe(gauche(a))
-    visiter(A)
+   visiter(a)
-    si est_pas_vide(droite(A))
+   si est_pas_vide(droite(a))
-       parcours_infixe(droite(A))
+      parcours_infixe(droite(a))
 ```
 ## Remarque 
@@ -600,8 +281,7 @@ typedef struct _node {
    struct _node* left;
    struct _node* right;
 } node;
-typedef node* tree_t;
+void tree_print(node *tree, int n) {
-void tree_print(tree_t tree, int n) {
    if (NULL != tree) {
        tree_print(tree->left, n+1);
        for (int i = 0; i < n; i++) {
@@ -626,7 +306,7 @@ void tree_print(tree_t tree, int n) {
 ## OK, alors deux exercices:
 1. Écrire le pseudo-code pour le parcours R, G, D (matrix).
-2. Écrire le pseudo-code pour la parcours G, D, R (matrix),
+2. Écrire le pseudo-code pour la parcours G, D, R (matrix).
 ## Rappel
@@ -643,7 +323,7 @@ parcours_infixe(arbre a)
 \footnotesize
-* Les deux parcours sont des modifications **triviales**[^2] de l'algorithme
+* Les deux parcours sont des modifications **triviales** de l'algorithme
  infixe.
 ## Le parcours postfixe
@@ -704,7 +384,7 @@ exercice (inspirez vous de ce qu'on a fait avant)!
 . . .
 ```C 
-void pretty_print(tree_t tree, int n) {
+void pretty_print(node *tree, int n) {
    if (NULL != tree) {
        pretty_print(tree->right, n+1);
        for (int i = 0; i < n; ++i) {
@@ -721,7 +401,7 @@ void pretty_print(tree_t tree, int n) {
 Écrire le code de la fonction 
 ```C
-int depth(tree_t t);
+int depth(node *t);
 ```
 qui retourne la profondeur maximale d'un arbre.
@@ -749,18 +429,18 @@ sous-arbres de gauche et de droite.
 ## Exemple: les arbres lexicographiques
-* Chaque nœud contient une information de type ordonné, la **clé**,
+* Chaque nœud contient une information de type ordonné, la **clé**.
 * Par construction, pour chaque nœud $N$:
-    * Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.
+    * Toute clé du sous-arbre à gauche de $N$ est inférieure à la clé de $N$.
-    * Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.
+    * Toute clé du sous-arbre à droite de $N$ est inférieure à la clé de $N$.
 # Algorithme de recherche
 * Retourner le nœud si la clé est trouvée dans l'arbre.
 ```python
-arbre recherche(clé, arbre)
+tree 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)
@@ -783,14 +463,13 @@ typedef struct _node {
    struct _node* left;
    struct _node* right;
 } node;
-typedef node* tree_t;
+node *search(key_t key, node *tree) {
-tree_t search(key_t key, tree_t tree) {
+    node *current = tree;
-    tree_t current = tree;
    while (NULL != current) {
-        if (current->key > X) {
+        if (current->key > key) {
-            current = current->gauche;
+            current = current->left;
-        } else if (current->key < X){
+        } else if (current->key < key){
-            current = current->droite;
+            current = current->right;
        } else {
            return current;
        }
@@ -804,7 +483,7 @@ tree_t search(key_t key, tree_t tree) {
 Écrire le code de la fonction
 ```C 
-int tree_size(tree_t tree);
+int tree_size(node *tree);
 ```
 qui retourne le nombre total de nœuds d'un arbre et poster le résultat sur
@@ -816,7 +495,7 @@ additionné au nombre de nœuds dans le sous-arbre de droite.
 . . .
 ```C
-int arbre_size(tree_t tree) {
+int tree_size(node *tree) {
    if (NULL == tree) {
        return 0;
    } else {   
@@ -828,7 +507,7 @@ int arbre_size(tree_t tree) {
 # 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
@@ -861,8 +540,7 @@ int arbre_size(tree_t tree) {
 * Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5 
+# Pseudo-code d'insertion (1/4)
-# Pseudo-code d'insertion (1/2)
 * Deux parties:
    * Recherche le parent où se passe l'insertion.
@@ -871,7 +549,7 @@ int arbre_size(tree_t tree) {
 ## Recherche du parent
 ```
-arbre position(arbre, clé)
+tree position(arbre, clé)
    si est_non_vide(arbre)
        si clé < clé(arbre)
            suivant = gauche(arbre)
@@ -887,7 +565,7 @@ arbre position(arbre, clé)
    retourne arbre
 ```
-# Pseudo-code d'insertion (2/2)
+# Pseudo-code d'insertion (2/4)
 * Deux parties:
    * Recherche de la position.
@@ -896,7 +574,7 @@ arbre position(arbre, clé)
 ## Ajout de l'enfant
 ```
-ajout(arbre, clé)
+rien ajout(arbre, clé)
    si est_vide(arbre)
        arbre = nœud(clé)
    sinon
@@ -915,19 +593,301 @@ ajout(arbre, clé)
 . . .
 ```C
-tree_t position(tree_t tree, key_t key) {
+node *position(node *tree, key_t key) {
-    tree_t current = tree;
+    node * current = tree;
    if (NULL != current) {
-        tree_t subtree = key > current->key ? current->right :
+        node *subtree = key > current->key 
-        current->left;
+                        ? current->right : current->left;
        while (key != current->key && NULL != subtree) {
            current = subtree;
-            subtree = key > current->key ? current->right :
+            subtree = key > current->key 
-            current->left;
+                      ? current->right : current->left;
        }
    }
    return current;
 }
 ```
-[^2]: Copyright cours de mathématiques pendant trop d'années.
+# L'insertion (3/4)
+* Deux parties:
+    * Recherche de la position.
+    * Ajout dans l'arbre.
+## Ajout du fils (pseudo-code)
+```
+rien ajout(arbre, clé)
+    si est_vide(arbre)
+        arbre = nœud(clé)
+    sinon
+        arbre = position(arbre, clé)
+        si clé < clé(arbre)
+            gauche(arbre) = nœud(clé)
+        sinon si clé > clé(arbre)
+            droite(arbre) = nœud(clé)
+        sinon
+            retourne
+```
+# L'insertion (4/4)
+## Ajout du fils (code)
+\scriptsize
+* 2 cas: arbre vide ou pas.
+* on retourne un pointeur vers le nœud ajouté (ou `NULL`)
+. . .
+```C
+node *add_key(node **tree, key_t key) {
+    node *new_node = calloc(1, sizeof(*new_node));
+    new_node->key = key;
+    if (NULL == *tree) {
+        *tree = new_node;
+    } else {
+        node * 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;
+}
+```
+# La suppression de clé
+::: columns
+:::: column
+## Cas simples: 
+* le nœud est absent, 
+* le nœud est une feuille,
+* le nœuds a un seul fils.
+## Une feuille (le 19 p.ex.).
+```{.mermaid format=pdf width=150 loc=figs/}
+flowchart TB;
+    10-->20;
+    10-->5
+    20-->21
+    20-->19
+```
+::::
+:::: column
+## Un seul fils (le 20 p.ex.).
+```{.mermaid format=pdf width=400 loc=figs/}
+flowchart TB;
+    10-->20;
+    10-->5
+    20-->25
+    20-->18
+    25-->24
+    25-->30
+    5-->4;
+    5-->8;
+    style 18 fill:#fff,stroke:#fff,color:#fff
+```
+## Dans tous les cas
+* Chercher le nœud à supprimer: utiliser `position()`.
+::::
+:::
+# La suppression de clé
+::: columns
+:::: column
+## Cas compliqué
+* Le nœud à supprimer a (au moins) deux descendants (10).
+```{.mermaid format=pdf width=400 loc=figs/}
+flowchart TB;
+    10-->20;
+    10-->5
+    20-->25
+    20-->18
+    25-->24
+    25-->30
+    5-->4;
+    5-->8;
+```
+::::
+:::: column
+* Si on enlève 10, il se passe quoi?
+. . .
+* On ne peut pas juste enlever `10` et recoller...
+* Proposez une solution !
+. . .
+## Solution
+* Échange de la valeur à droite dans le sous-arbre de gauche ou ...
+* de la valeur de gauche dans le sous-arbre de droite!
+* Puis, on retire le nœud.
+::::
+:::
+# Le pseudo-code de la suppression
+## Pour une feuille ou absent (ensemble)
+```
+tree 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`
+## Pseudo-code pour trouver le parent (5min -> matrix)
+. . .
+```
+tree 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
+                    actuel = droite(actuel)
+            sinon
+                retour parent
+        tant_que (actuel != sous_arbre)
+    retourne vide
+```
+# Le pseudo-code de la suppression
+\footnotesize
+## Pour un seul enfant (5min -> matrix)
+. . .
+```
+tree 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
+            si droite(parent) == sous_arbre
+                droite(parent) = gauche(sous_arbre)
+            sinon
+                gauche(parent) = gauche(sous_arbre)
+        retourne sous_arbre
+```
+# Le pseudo-code  de la suppression
+\footnotesize
+## Pour au moins deux enfants (ensemble)
+```
+tree 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.
+. . .
+```
+tree insertion(arbre, clé)
+    si est_vide(arbre)
+        retourne nœud(clé)
+    si (clé < arbre->clé)
+        gauche(arbre) = insert(gauche(arbre), clé)
+    sinon
+        droite(arbre) = insert(droite(arbre), clé)
+    retourne arbre
+```
+# Exercices (poster sur matrix)
+2. Écrire le pseudo-code de la recherche purement en récursif.
+. . .
+```
+booléen recherche(arbre, clé)
+    si est_vide(arbre)
+        retourne faux // pas trouvée
+    si clé(arbre) == clé
+        retourne vrai // trouvée
+    si clé < clé(arbre)
+        retourne recherche(gauche(arbre), clé)
+    sinon
+        retourne recherche(droite(arbre), clé)
+```
+# Exercices (à la maison)
+3. Écrire une fonction qui insère des mots dans un arbre et ensuite affiche
+   l'arbre.
--- a/slides/cours_17.md
+++ b/slides/cours_17.md
 ---
-title: "Arbres"
+title: "Arbres binaires, tri par tas"
-date: "2024-03-12"
+date: "2025-03-14"
 ---
-# Rappel: arbre binaire
+# Les arbres binaires
-## Qu'est-ce qu'un arbre binaire?
+\Huge Les arbres binaires
-. . .
+# Rappel pour l'insertion
-* Structure de données abstraite,
-* Chaque nœud a au plus deux enfants: gauche et droite,
-* Chaque enfants est un arbre.
-# Rappel: parcous (infixe, GRD)
-. . .
-```
-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))
-```
-# Rappel: parcours (postfixe, GDR)
-. . .
-```python
-parcours_postfixe(arbre a)
-    si est_pas_vide(gauche(a))
-       parcours_postfixe(gauche(a))
-    si est_pas_vide(droite(a))
-       parcours_postfixe(droite(a))
-    visiter(a)
-```
-# Rappel: parcours (préfixe, RGD)
-. . .
-```python
-parcours_préfixe(arbre a)
-    visiter(a)
-    si est_pas_vide(gauche(a))
-        parcours_préfixe(gauche(a))
-    si est_pas_vide(droite(a))
-        parcours_préfixe(droite(a))
-```
-# La recherche dans un arbre binaire
-* Les arbres binaires peuvent retrouver une information très rapidement.
-* À quelle complexité? À quelle condition?
-. . .
-## Condition
-* Le contenu de l'arbre est **ordonné** (il y a une relation d'ordre (`<`, `>`
-  entre les éléments).
-## Complexité
-* La profondeur de l'arbre (ou le $\mathcal{O}(\log_2(N))$)
-. . .
-## Exemple: les arbres lexicographiques
-* Chaque nœud contient une information de type ordonné, la **clé**,
-* Par construction, pour chaque nœud $N$:
-    * Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.
-    * Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.
-# Algorithme de recherche
+* Les éléments insérés ont une notion d'ordre
+* On parcourt l'arbre jusqu'à pouvoir ajouter une nouvelle feuille
-* Retourner le nœud si la clé est trouvée dans l'arbre.
+# Pseudo-code d'insertion (1/4)
-```python
-arbre recherche(clé, arbre)
-    tante_que est_non_vide(arbre)
-        si clé < clé(arbre)
-            arbre = gauche(arbre)
-        sinon si clé > clé(arbre)
-            arbre = droite(arbre)
-        sinon
-            retourne arbre
-    retourne NULL
-```
-# Algorithme de recherche, implémentation (live)
 \footnotesize
-. . .
-```C 
-typedef int key_t;
-typedef struct _node {
-    key_t key;
-    struct _node* left;
-    struct _node* right;
-} node;
-node * search(key_t key, node * tree) {
-    node * current = tree;
-    while (NULL != current) {
-        if (current->key > X) {
-            current = current->gauche;
-        } else if (current->key < X){
-            current = current->droite;
-        } else {
-            return current;
-        }
-    }
-    return NULL;
-}
-```
-# Exercice (5-10min)
-Écrire le code de la fonction
-```C 
-int tree_size(node * tree);
-```
-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.
-. . .
-```C
-int arbre_size(node * tree) {
-    if (NULL == tree) {
-        return 0;
-    } else {   
-        return 1 + tree_size(tree->left) 
-            + tree_size(tree->right);
-    }
-}
-```
-# L'insertion dans un arbre binaire
-* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut
-  pas construire l'arbre....
-## Pour un arbre lexicographique
-* Rechercher la position dans l'arbre où insérer.
-* Créer un nœud avec la clé et le rattacher à l'arbre.
-# Exemple d'insertions
-* 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
-```
-```
-## Exercice (3min, puis matrix)
-* Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5 
-# Pseudo-code d'insertion (1/4)
 * Deux parties:
    * Recherche le parent où se passe l'insertion.
    * Ajout de l'enfant dans l'arbre.
 ## Recherche du parent
-```
+```python
-arbre position(arbre, clé)
+arbre position(tree, clé)
-    si est_non_vide(arbre)
+    si est_non_vide(tree)
-        si clé < clé(arbre)
+        si clé < clé(tree)
-            suivant = gauche(arbre)
+            suivant = gauche(tree)
        sinon
-            suivant = droite(arbre)
+            suivant = droite(tree)
-        tant que clé(arbre) != clé && est_non_vide(suivant)
+        tant que clé(tree) != clé && est_non_vide(suivant)
-            arbre = suivant
+            tree = suivant
-            si clé < clé(arbre)
+            si clé < clé(tree)
-                suivant = gauche(arbre)
+                suivant = gauche(tree)
            sinon
-                suivant = droite(arbre)
+                suivant = droite(tree)
-    retourne arbre
+    retourne tree
 ```
 # Pseudo-code d'insertion (2/4)
@@ -218,14 +48,14 @@ arbre position(arbre, clé)
 ## Ajout de l'enfant
 ```
-ajout(arbre, clé)
+rien ajout(tree, clé)
-    si est_vide(arbre)
+    si est_vide(tree)
-        arbre = nœud(clé)
+        tree = nœud(clé)
    sinon
-        si clé < clé(arbre)
+        si clé < clé(tree)
-            gauche(arbre) = nœud(clé)
+            gauche(tree) = nœud(clé)
-        sinon si clé > clé(arbre)
+        sinon si clé > clé(tree)
-            droite(arbre) = nœud(clé)
+            droite(tree) = nœud(clé)
        sinon
            retourne
 ```
@@ -240,12 +70,12 @@ ajout(arbre, clé)
 node *position(node *tree, key_t key) {
    node * current = tree;
    if (NULL != current) {
-        node * subtree = key > current->key ? current->right :
+        node *subtree = key > current->key 
-            current->left;
+                        ? current->right : current->left;
        while (key != current->key && NULL != subtree) {
            current = subtree;
-            subtree = key > current->key ? current->right :
+            subtree = key > current->key 
-            current->left;
+                      ? current->right : current->left;
        }
    }
    return current;
@@ -261,15 +91,15 @@ node * position(node * tree, key_t key) {
 ## Ajout du fils (pseudo-code)
 ```
-rien ajout(arbre, clé)
+rien ajout(tree, clé)
-    si est_vide(arbre)
+    si est_vide(tree)
-        arbre = nœud(clé)
+        tree = nœud(clé)
    sinon
-        arbre = position(arbre, clé)
+        tree = position(tree, clé)
-        si clé < clé(arbre)
+        si clé < clé(tree)
-            gauche(arbre) = nœud(clé)
+            gauche(tree) = nœud(clé)
-        sinon si clé > clé(arbre)
+        sinon si clé > clé(tree)
-            droite(arbre) = nœud(clé)
+            droite(tree) = nœud(clé)
        sinon
            retourne
 ```
@@ -289,7 +119,7 @@ rien ajout(arbre, clé)
 ```C
 node *add_key(node **tree, key_t key) {
-    node_t *new_node = calloc(1, sizeof(*new_node));
+    node *new_node = calloc(1, sizeof(*new_node));
    new_node->key = key;
    if (NULL == *tree) {
        *tree = new_node;
@@ -309,8 +139,11 @@ node * add_key(node **tree, key_t key) {
 }
 ```
-# La suppression de clé
+# La suppression dans un arbre binaire
+\Huge La suppression dans un arbre binaire
+# La suppression de clé
 ::: columns
@@ -319,7 +152,7 @@ node * add_key(node **tree, key_t key) {
 ## Cas simples: 
 * le nœud est absent, 
-* le nœud est une feuille
+* le nœud est une feuille,
 * le nœuds a un seul fils.
 ## Une feuille (le 19 p.ex.).
@@ -328,8 +161,8 @@ node * add_key(node **tree, key_t key) {
 flowchart TB;
    10-->20;
    10-->5
-    20-->21
    20-->19
+    20-->21
 ```
 ::::
@@ -368,7 +201,7 @@ flowchart TB;
 ## Cas compliqué
-* Le nœud à supprimer à (au moins) deux descendants (10).
+* Le nœud à supprimer a (au moins) deux descendants (10).
 ```{.mermaid format=pdf width=400 loc=figs/}
 flowchart TB;
@@ -386,19 +219,18 @@ flowchart TB;
 :::: column
-* Si on enlève 10 il se passe quoi?
+* Si on enlève 10, il se passe quoi?
 . . .
-* On peut pas juste enlever `10` et recoller...
+* On ne peut pas juste enlever `10` et recoller...
-* Proposez une solution bon sang!
+* Proposez une solution !
 . . .
 ## Solution
-* Échange de la valeur à droite dans le sous-arbre de gauche ou
+* Échange de la valeur à droite dans le sous-arbre de gauche ou ...
-  ...
 * de la valeur de gauche dans le sous-arbre de droite!
 * Puis, on retire le nœud.
@@ -406,3 +238,1078 @@ flowchart TB;
 :::
+# Le pseudo-code  de la suppression
+## Pour une feuille ou absent (ensemble)
+```
+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`
+## Pseudo-code pour trouver le parent (5min -> matrix)
+. . .
+```
+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
+                    actuel = droite(actuel)
+            sinon
+                retour parent
+        tant_que (actuel != sous_arbre)
+    retourne vide
+```
+# Le pseudo-code  de la suppression
+\footnotesize
+## Pour un seul enfant (5min -> matrix)
+. . .
+```
+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
+            si droite(parent) == sous_arbre
+                droite(parent) = gauche(sous_arbre)
+            sinon
+                gauche(parent) = gauche(sous_arbre)
+        retourne sous_arbre
+```
+# Le pseudo-code  de la suppression
+\footnotesize
+## Pour au moins deux enfants (ensemble)
+```
+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.
+. . .
+```
+arbre insert(tree, clé)
+    si est_vide(tree)
+        retourne nœud(clé)
+    si (clé < tree(clé))
+        gauche(tree) = insert(gauche(tree), clé)
+    sinon
+        droite(tree) = insert(droite(tree), clé)
+    retourne tree
+```
+# Exercices (poster sur matrix)
+2. Écrire le pseudo-code de la recherche purement en récursif.
+. . .
+```
+booléen recherche(tree, clé)
+    si est_vide(tree)
+        retourne faux // pas trouvée
+    si clé(tree) == clé
+        retourne vrai // trouvée
+    si clé < clé(tree)
+        retourne recherche(gauche(tree), clé)
+    sinon
+        retourne recherche(droite(tree), clé)
+```
+# Exercices (à la maison)
+3. Écrire une fonction qui insère des mots dans un arbre et ensuite affiche l'arbre.
+# Le tri par tas
+\Huge Le tri par tas
+# Trier un tableau à l'aide d'un arbre binaire
+* Tableau représenté comme un arbre binaire.
+* Aide à comprendre "comment" trier, mais on ne construit jamais l'arbre.
+* Complexité $O(N\log_2 N)$ en moyenne et grande stabilité (pas de cas
+  dégénérés).
+# Lien entre arbre et tableau
+* La racine de l'arbre est le premier élément du tableau.
+* Les deux fils d'un nœud d'indice $i$, ont pour indices $2i+1$ et $2i+2$:
+    * Les fils du nœud $i=0$ sont en $2\cdot 0+1=1$ et $2\cdot 0+2=2$.
+    * Les fils du nœud $i=1$ sont en $2\cdot 1+1=3$ et $2\cdot 1+2=4$.
+    * Les fils du nœud $i=2$ sont en $2\cdot 2+2=5$ et $2\cdot 1+2=6$.
+    * Les fils du nœud $i=3$ sont en $2\cdot 3+1=7$ et $2\cdot 3+2=8$.
+* Un élément d'indice $i$ a pour parent l'élément $(i-1)/2$ (division entière):
+    * Le parent du nœud $i=8$ est $(8-1)/2=3$.
+    * Le parent du nœud $i=7$ est $(7-1)/2=3$.
+# Visuellement
+::: columns
+:::: column
+* Où vont les indices correspondant du tableau?
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0(( ))-->id1(( ));
+    id0-->id2(( ));
+    id1-->id3(( ));
+    id1-->id4(( ));
+    id2-->id5(( ));
+    id2-->id6(( ));
+    id3-->id7(( ));
+    id3-->id8(( ));
+    id4-->id9(( ));
+    id4-->id10(( ));    
+    style id10 fill:#fff,stroke:#fff
+```
+::::
+:::: column
+* Les flèches de gauche à droite, parent -> enfants.
+* Les flèches de droite à gauche, enfants -> parent.
+![Dualité tableau arbre binaire.](figs/heap_tree.svg)
+::::
+:::
+**Propriétés:** 
+1. les feuilles sont toutes sur l'avant dernier ou dernier niveau.
+2. les feuilles de profondeur maximale sont "tassées" à gauche.
+# Le tas (ou heap)
+## Définition
+* Un arbre est un tas, si la valeur de chacun de ses descendants est inférieure
+  ou égale à sa propre valeur.
+## Exemples (ou pas)
+```
+16  8 14 6 2 10 12 4 5 # Tas
+16 14  8 6 2 10 12 4 5 # Non-tas, 10 > 8 et 12 > 8
+```
+## Exercices (ou pas)
+```
+19 18 12 12 17 1 13 4 5 # Tas ou pas tas?
+19 18 16 12 17 1 12 4 5 # Tas ou pas tas?
+```
+. . .
+```
+19 18 12 12 17 1 13 4 5 # Pas tas! 13 > 12
+19 18 16 12 17 1 12 4 5 # Tas!
+```
+# Exemple de tri par tas (1/13)
+```
+        | 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-1 = 4$: `4`.
+* `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/13)
+```
+        | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
+```
+::: columns
+:::: column
+**But:** Transformer l'arbre en tas.
+* On continue à l'indice $N/2-2 = 3$: `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-3 = 2$: `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/13)
+```
+        | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
+```
+::: columns
+:::: column
+**But:** Transformer l'arbre en tas.
+* Indice $N/2-2 = 3$: `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-3 = 2$: `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/13)
+```
+        | 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
+```
+::: columns
+:::: column
+**But:** Transformer l'arbre en tas.
+* Indice $N/2-4 = 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-5 = 0$: `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/13)
+```
+        | 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/13)
+```
+        | 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/13)
+```
+        | 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/13)
+```
+        | 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/13)
+```
+        | 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/13)
+```
+        | 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=150 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=150 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/13)
+```
+        | 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=150 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/13)
+```
+        | 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/13)
+```
+        | 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/2)
+\footnotesize
+## Deux étapes
+1. Entassement: 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 (15 min, matrix)
+. . .
+```python
+rien tri_par_tas(tab)
+    entassement(tab)
+    échanger(tab[0], tab[size(tab)-1])
+    pour i de size(tab)-1 à 2 
+        tamisage(tab, 0)
+        échanger(tab[0], tab[i-1])
+rien entassement(tab)
+    pour i de size(tab)/2-1 à 0
+        tamisage(tab, i)
+rien tamisage(tab, i)
+    ind_max = ind_max(tab, i, gauche(i), droite(i))
+    si i != ind_max
+        échanger(tab[i], tab[ind_max])
+        tamisage(tab, ind_max)
+```
+# L'algorithme du tri par tas (2/2)
+* Fonctions utilitaires
+    ```python
+    entier ind_max(tab, i, g, d)
+        ind_max = i
+        si g < size(tab) && tab[ind_max] < tab[g] 
+            ind_max = g
+        si d < size(tab) > d && tab[ind_max] < tab[d]
+            ind_max = d
+        retourne ind_max
+    entier gauche(i)
+        retourne 2 * i + 1
+    entier 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 (4/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;
+}
+``` -->
--- a/slides/cours_18.md
+++ b/slides/cours_18.md
 ---
-title: "Arbres et tas"
+title: "Arbres AVL"
-date: "2024-03-19"
+date: "2025-03-21"
 ---
-# Rappel: L'insertion
+# Exercice (que vous avez dû faire à la maiso)
+* Trier par tas le tableau
 ```
-rien ajout(arbre, clé)
+        | 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
-    si est_vide(arbre)
-        arbre = nœud(clé)
-    sinon
-        arbre = position(arbre, clé)
-        si clé < clé(arbre)
-            gauche(arbre) = nœud(clé)
-        sinon si clé > clé(arbre)
-            droite(arbre) = nœud(clé)
-        sinon
-            retourne
 ```
-# La suppression de clé
+* Mettez autant de détails que possible.
+* Que constatez-vous?
-::: columns
+* Postez le résultat sur matrix.
-:::: column
+# L'algorithme du tri par tas (1/2)
-## Cas simples: 
+\footnotesize
-* le nœud est absent, 
+## Deux étapes
-* le nœud est une feuille
-* le nœuds a un seul fils.
-## Une feuille (le 19 p.ex.).
+1. Entassement: transformer l'arbre en tas.
+2. Échanger la racine avec le dernier élément et entasser la racine.
-```{.mermaid format=pdf width=150 loc=figs/}
+## Pseudo-code d'entassement de l'arbre (15 min, matrix)
-flowchart TB;
-    10-->20;
-    10-->5
-    20-->21
-    20-->19
-```
-::::
+. . .
-:::: column
+```python
+rien tri_par_tas(tab)
+    entassement(tab)
+    échanger(tab[0], tab[size(tab)-1])
+    pour i de size(tab)-1 à 2 
+        tamisage(tab, 0)
+        échanger(tab[0], tab[i-1])
-## Un seul fils (le 20 p.ex.).
+rien entassement(tab)
+    pour i de size(tab)/2-1 à 0
+        tamisage(tab, i)
-```{.mermaid format=pdf width=400 loc=figs/}
+rien tamisage(tab, i)
-flowchart TB;
+    ind_max = ind_max(tab, i, gauche(i), droite(i))
-    10-->20;
+    si i != ind_max
-    10-->5
+        échanger(tab[i], tab[ind_max])
-    20-->25
+        tamisage(tab, ind_max)
-    20-->18
-    25-->24
-    25-->30
-    5-->4;
-    5-->8;
-    style 18 fill:#fff,stroke:#fff,color:#fff
 ```
-## Dans tous les cas
+# L'algorithme du tri par tas (2/2)
-* Chercher le nœud à supprimer: utiliser `position()`.
+* Fonctions utilitaires
-::::
+    ```python
+    entier ind_max(tab, i, g, d)
+        ind_max = i
+        si g < size(tab) && tab[ind_max] < tab[g] 
+            ind_max = g
+        si d < size(tab) > d && tab[ind_max] < tab[d]
+            ind_max = d
+        retourne ind_max
-:::
+    entier gauche(i)
+        retourne 2 * i + 1
-# La suppression de clé
+    entier droite(i)
+        retourne 2 * i + 2
+    ```
-::: columns
+<!-- # L'algorithme du tri par tas (3/4)
-:::: column
+\footnotesize
-## Cas compliqué
+## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
-* Le nœud à supprimer à (au moins) deux descendants (10).
+. . .
-```{.mermaid format=pdf width=400 loc=figs/}
+```C 
-flowchart TB;
+void heapsort(int size, int tab[size]) {
-    10-->20;
+    heapify(size, tab);
-    10-->5
+    swap(tab, tab + size - 1);
-    20-->25
+    for (int s = size - 1; s > 1; s--) {
-    20-->18
+        sift_up(s, tab, 0);
-    25-->24
+        swap(tab, tab + s - 1);
-    25-->30
+    }
-    5-->4;
+}
-    5-->8;
+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 (4/4)
-:::: column
+\footnotesize
-* Si on enlève 10 il se passe quoi?
+## Fonctions utilitaires
 . . .
-* On peut pas juste enlever `10` et recoller...
+```C
-* Proposez une solution bon sang!
+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;
+}
+``` -->
-. . .
-## Solution
-* Échange de la valeur à droite dans le sous-arbre de gauche ou
-  ...
-* de la valeur de gauche dans le sous-arbre de droite!
-* Puis, on retire le nœud.
-::::
+# Les arbres AVL
-:::
+\Huge Les arbres AVL
+# Un meilleur arbre
+* Quelle propriété doit satisfaire un arbre pour que la recherche soit $O(\log_2(N))$?
-# Le pseudo-code  de la suppression
+. . .
-## Pour une feuille ou absent (ensemble)
+* Si on a environ le même nombre de nœuds dans les sous-arbres.
-```
+## Définition
-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`
+Un arbre binaire est parfaitement équilibré si, pour chaque
+nœud, la différence entre les nombres de nœuds des sous-
+arbres gauche et droit vaut au plus 1.
-## Pseudo-code pour trouver le parent (5min -> matrix)
+* Si l'arbre est **parfaitement équilibré**, alors tout ira bien.
+* Quelle est la hauteur (profondeur) d'un arbre parfaitement équilibré?
 . . .
-```
+* $O(\log_2(N))$.
-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
-                    actuel = droite(actuel)
-            sinon
-                retour parent
-        tant_que (actuel != sous_arbre)
-    retourne vide
-```
-# Le pseudo-code  de la suppression
-\footnotesize
+# Équilibre parfait ou pas?
+::: columns
+:::: column
-## Pour un seul enfant (5min -> matrix)
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((W))-->id1((B));
+    id0-->id8((Y));
+    id1-->id2((A));
+    id1-->id9((  ));
+    id8-->id10((X));
+    id8-->id11((  ));
+    style id9 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
+```
+::::
+:::: column
 . . .
 ```
-arbre suppression(arbre, clé)
+É
-    sous_arbre = position(arbre, clé)
+Q
-    si est_vide(gauche(sous_arbre)) ou est_vide(droite(sous_arbre))
+U
-        parent = parent(arbre, sous_arbre)
+I
-        si est_vide(gauche(sous_arbre))
+L
-            si droite(parent) == sous_arbre
+I
-                droite(parent) = droite(sous_arbre)
+B
-            sinon
+R
-                gauche(parent) = droite(sous_arbre)
+É
-        sinon
-            si droite(parent) == sous_arbreou est_
-                droite(parent) = gauche(sous_arbre)
-            sinon
-                gauche(parent) = gauche(sous_arbre)
-        retourne sous_arbre
 ```
+::::
-# Le pseudo-code  de la suppression
+:::
-\footnotesize
+# Équilibre parfait ou pas?
+::: columns
-## Pour au moins deux enfants (ensemble)
+:::: column
-```
+```{.mermaid format=pdf width=400 loc=figs/}
-arbre suppression(arbre, clé)
+graph TD;
-    sous_arbre = position(arbre, clé) # on revérifie pas que c'est bien la clé
+    id0((16))-->id1((10));
-    si est_non_vide(gauche(sous_arbre)) et est_non_vide(droite(sous_arbre))
+    id0-->id2((19));
-        max_gauche = position(gauche(sous_arbre), clé)
+    id1-->id3((8));
-        échange(clé(max_gauche), clé(sous_arbre))
+    id1-->id4((12));
-        suppression(gauche(sous_arbre), clé)
+    id4-->id5((11));
+    id4-->id6((  ));
+    id2-->id7((17));
+    id2-->id8((  ));
+    id7-->id9((  ));
+    id7-->id10((18));
+    style id6 fill:#fff,stroke:#fff
+    style id8 fill:#fff,stroke:#fff
+    style id9 fill:#fff,stroke:#fff
 ```
-# Exercices (poster sur matrix)
+::::
-1. Écrire le pseudo-code de l'insertion purement en récursif.
+:::: column
 . . .
 ```
-arbre insertion(arbre, clé)
+P 
-    si est_vide(arbre)
+A
-        retourne nœud(clé)
+S 
-    si (clé < arbre->clé)
+É
-        gauche(arbre) = insert(gauche(arbre), clé)
+Q
-    sinon
+U
-        droite(arbre) = insert(droite(arbre), clé)
+I
-    retourne arbre
+L
+I
+B
+R
+É
 ```
-# Exercices (poster sur matrix)
+::::
+:::
+# Arbres AVL
+\footnotesize
-2. Écrire le pseudo-code de la recherche purement en récursif.
+* Quand est-ce qu'on équilibre un arbre?
 . . .
-```
+* A l'insertion/suppression.
-bool recherche(arbre, clé)
+* Maintenir un arbre en état d'équilibre parfait: cher (insertion, suppression).
-    si est_vide(arbre)
+* On peut "relaxer" la condition d'équilibre: profondeur (hauteur) au lieu du
-        retourne faux // pas trouvée
+  nombre de nœuds:
-    si clé(arbre) == clé
+    * La hauteur $\sim\log_2(N)$.
-        retourne vrai // trouvée
-    si clé < clé(arbre)
-        retourne recherche(gauche(arbre), clé)
-    sinon
-        retourne recherche(droite(arbre), clé)
-```
-# Exercices (à la maison)
+## Définition
+Un arbre AVL (Adelson-Velskii et Landis) est un arbre binaire de recherche dans
+lequel, pour chaque nœud, la différence de hauteur entre le sous-arbre gauche et droit vaut au plus 1.
-3. Écrire une fonction qui insère des mots dans un arbre et ensuite affiche
+* Relation entre nœuds et hauteur:
-   l'arbre.
+$$
+\log_2(1+N)\leq 1+H\leq 1.44\cdot\log_2(2+N),\quad N=10^5,\ 17\leq H \leq 25.
+$$
+* Permet l'équilibrage en temps constant: insertion/suppression $O(\log_2(N))$.
-# Trier un tableau à l'aide d'un arbre binaire
+# Notation
-* Tableau représenté comme un arbre binaire.
+* `hg`: hauteur du sous-arbre gauche.
-* Aide à comprendre "comment" trier, mais on ne construit jamais l'arbre.
+* `hd`: hauteur du sous-arbre droit.
-* Complexité $O(N\log_2 N)$ en moyenne et grande stabilité (pas de cas
+* `facteur d'équilibre = fe = hd - hg`
-  dégénérés).
+* Que vaut `fe` si l'arbre est AVL?
-# Lien entre arbre et tableau
+. . .
-* La racine de l'arbre set le premier élément du tableau.
+* `fe = {-1, 0, 1}`
-* Les deux fils d'un nœud d'indice $i$, ont pour indices $2i+1$ et $2i+2$:
-    * Les fils du nœud $i=0$, sont à $2\cdot 0+1=1$ et $2\cdot 0+2=2$.
-    * Les fils du nœud $i=1$, sont à $2\cdot 1+1=3$ et $2\cdot 1+2=4$.
-    * Les fils du nœud $i=2$, sont à $2\cdot 2+2=5$ et $2\cdot 1+2=6$.
-    * Les fils du nœud $i=3$, sont à $2\cdot 3+1=7$ et $2\cdot 3+2=8$.
-* Un élément d'indice $i$ a pour parent l'élément $(i-1)/2$ (division entière):
-    * Le parent du nœud $i=8$ est $(8-1)/2=3$.
-    * Le parent du nœud $i=7$ est $(7-1)/2=3$.
-# Visuellement
+# AVL ou pas?
 ::: columns
 :::: column
-* Où vont les indices correspondant du tableau?
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0(( ))-->id1(( ));
+    id0((12))-->id1((10));
-    id0-->id2(( ));
+    id0-->id2((19));
-    id1-->id3(( ));
+    id2-->id3((17));
-    id1-->id4(( ));
+    id2-->id4((97));
-    id2-->id5(( ));
-    id2-->id6(( ));
-    id3-->id7(( ));
-    id3-->id8(( ));
-    id4-->id9(( ));
-    id4-->id10(( ));    
-    style id10 fill:#fff,stroke:#fff
 ```
 ::::
 :::: column
-* Les flèche de gauche à droite, parent -> enfants.
+. . .
-* Les flèche de droite à gauche, enfants -> parent.
-![Dualité tableau arbre binaire.](figs/heap_tree.svg)
+```
+A
+V
+L
+```
 ::::
 :::
-**Propriétés:** 
+# AVL ou pas?
+::: columns
-1. les feuilles sont toutes sur l'avant dernier ou dernier niveau.
+:::: column
-2. les feuilles de profondeur maximale sont "tassée" à gauche.
-# Le tas (ou heap)
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((12))-->id1((1));
+    id0-->id2((19));
+    id2-->id3((17));
+    id2-->id4((97));
+    id4-->id5((37));
+    id4-->id6((  ));
+    style id6 fill:#fff,stroke:#fff
+```
-## Définition
+::::
-* Un arbre est un tas, si la valeur de chacun de ses descendants est inférieure
+:::: column
-  ou égale à sa propre valeur.
-## Exemples (ou pas)
+. . .
 ```
-16  8 14 6 2 10 12 4 5 # Tas
+P
-16 14  8 6 2 10 12 4 5 # Non-tas, 10 > 8 et 12 > 8
+A
+S
+A
+V
+L
 ```
-## Exercices (ou pas)
+::::
+:::
+# Insertion dans un arbre AVL (1/N)
+1. On part d'un arbre AVL.
+2. On insère un nouvel élément.
+::: columns
+:::: column
+* `hd ? hg`.
+* Insertion de `4`?
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((12))-->id1((1));
+    id0-->id2((19));
 ```
-19 18 12 12 17 1 13 4 5 # Tas ou pas tas?
-19 18 16 12 17 1 12 4 5 # Tas ou pas tas?
+::::
-```
+:::: column
 . . .
-```
+* `hd = hg`
-19 18 12 12 17 1 13 4 5 # Pas tas! 13 > 12
-19 18 16 12 17 1 12 4 5 # Tas!
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((12))-->id1((1));
+    id0-->id2((19));
+    id1-->id4((  ));
+    id1-->id5((4));
+    style id4 fill:#fff,stroke:#fff
 ```
-# Exemple de tri par tas (1/13)
+* `fe = -1`
-```
+::::
-        | 1 | 16 | 5 | 12 | 4 | 2 | 8 | 10 | 6 | 7 |
-```
+:::
+# Insertion dans un arbre AVL (2/N)
+1. On part d'un arbre AVL.
+2. On insère un nouvel élément.
 ::: columns
 :::: column
-* Quel est l'arbre que cela représente?
+* `hd ? hg`.
+* Insertion de `4`?
-. . .
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((1))-->id1((16));
+    id0((12))-->id1((1));
-    id0-->id2((5));
+    id0-->id2((19));
-    id1-->id3((12));
+    id2-->id3((18));
-    id1-->id4((4));
+    id2-->id4((  ));
-    id2-->id5((2));
+    style id4 fill:#fff,stroke:#fff
-    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$: `4`.
+* `hd < hg`
-* `7 > 4` (enfant `>` parent).
-* intervertir `4` et `7`.
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((1))-->id1((16));
+    id0((12))-->id1((1));
-    id0-->id2((5));
+    id0-->id2((19));
-    id1-->id3((12));
+    id2-->id3((18));
-    id1-->id4((7));
+    id2-->id4((  ));
-    id2-->id5((2));
+    id1-->id5((  ));
-    id2-->id6((8));
+    id1-->id6((4));
-    id3-->id7((10));
+    style id4 fill:#fff,stroke:#fff
-    id3-->id8((6));
+    style id5 fill:#fff,stroke:#fff
-    id4-->id9((4));
-    id4-->id10(( ));    
-    style id10 fill:#fff,stroke:#fff
 ```
+* `fe = 0`
 ::::
 :::
-. . .
+# Insertion dans un arbre AVL (3/N)
-```
+\footnotesize
-                            *                    *
-        | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
-```
-# Exemple de tri par tas (2/13)
-```
+1. On part d'un arbre AVL.
-        | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
+2. On insère un nouvel élément.
-```
 ::: columns
 :::: column
-**But:** Transformer l'arbre en tas.
+* `hd ? hg`.
+* Insertion de `4`?
-* 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((12))-->id1((1));
-    id0-->id2((5));
+    id0-->id2((19));
-    id1-->id3((12));
+    id1-->id3((  ));
-    id1-->id4((7));
+    id1-->id4((6));
-    id2-->id5((2));
+    id2-->id5((  ));
-    id2-->id6((8));
+    id2-->id6((  ));
-    id3-->id7((10));
+    style id3 fill:#fff,stroke:#fff
-    id3-->id8((6));
+    style id5 fill:#fff,stroke:#fff
-    id4-->id9((4));
+    style id6 fill:#fff,stroke:#fff
-    id4-->id10(( ));    
-    style id10 fill:#fff,stroke:#fff
 ```
 ::::
 :::: column
-**But:** Transformer l'arbre en tas.
+. . .
-* On continue à l'indice $N/2-2 = 3$: `5`.
+* `hd < hg`
-* `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((12))-->id1((1));
-    id0-->id2((8));
+    id0-->id2((19));
-    id1-->id3((12));
+    id1-->id3((  ));
-    id1-->id4((7));
+    id1-->id4((6));
-    id2-->id5((2));
+    id4-->id5((4));
-    id2-->id6((5));
+    id4-->id6((  ));
-    id3-->id7((10));
+    id2-->id7((  ));
-    id3-->id8((6));
+    id2-->id8((  ));
-    id4-->id9((4));
+    style id3 fill:#fff,stroke:#fff
-    id4-->id10(( ));    
+    style id6 fill:#fff,stroke:#fff
-    style id10 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id8 fill:#fff,stroke:#fff
 ```
 ::::
 :::
+**Déséquilibre!** Que vaut `fe`?
 . . .
-```
+* `fe = 2`
-        | 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
-```
-# Exemple de tri par tas (3/13)
+# Les cas de déséquilibre
-```
-        | 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
-```
 ::: columns
 :::: column
-**But:** Transformer l'arbre en tas.
+## Cas 1a
-* Indice $N/2-1 = 4$: `12`.
+* `u`, `v`, `w` même hauteur.
-* Déjà un tas, rien à faire.
+* déséquilibre en `B` après insertion dans `u`
-```{.mermaid format=pdf width=400 loc=figs/}
+![Après insertion](figs/cas1a_gauche.png)
-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.
+## Cas 1a
-* Indice $N/2-2 = 3$: `5`.
+* Comment rééquilibrer?
-* `5 < 8`, `5 <=> max(2, 5, 8)`
-```{.mermaid format=pdf width=400 loc=figs/}
+. . .
-graph TD;
-    id0((1))-->id1((16));
+* ramène `u`, `v` `w` à la même hauteur.
-    id0-->id2((8));
+* `v` à droite de `A` (gauche de `B`)
-    id1-->id3((12));
-    id1-->id4((7));
+![Après équilibrage](figs/cas1a_droite.png)
-    id2-->id5((2));
-    id2-->id6((5));
-    id3-->id7((10));
-    id3-->id8((6));
-    id4-->id9((4));
-    id4-->id10(( ));    
-    style id10 fill:#fff,stroke:#fff
-```
 ::::
 :::
-```
+# Les cas de déséquilibre
-                   *                *
-        | 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
-```
-# Exemple de tri par tas (4/13)
-```
+::: columns
-        | 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
-```
+:::: column
+## Cas 1b (symétrique 1a)
+![Après insertion](figs/cas1b_gauche.png)
+::::
+:::: column
+## Cas 1b (symétrique 1a)
+* Comment rééquilibrer?
+. . .
+![Après équilibrage](figs/cas1b_droite.png)
+::::
+:::
+# Les cas de déséquilibre
 ::: columns
 :::: column
-**But:** Transformer l'arbre en tas.
+## Cas 2a
-* Indice $N/2-3 = 1$: `16`.
+* `h(v1)=h(v2), h(u)=h(w)`.
-* Déjà un tas, rien à faire.
+* déséquilibre en `C` après insertion dans `v2`
-```{.mermaid format=pdf width=400 loc=figs/}
+![Après insertion](figs/cas2a_gauche.png)
-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.
+## Cas 2a
-* Indice $N/2-4 = 1$: `1`.
+* Comment rééquilibrer?
-* `1 < 16 && 1 < 8`, `1 <=> max(1, 16, 8)`
-```{.mermaid format=pdf width=400 loc=figs/}
+. . .
-graph TD;
-    id0((16))-->id1((1));
+* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
-    id0-->id2((8));
+* `v2` à droite de `B` (gauche de `C`)
-    id1-->id3((12));
+* `B` à droite de `A` (gauche de `C`)
-    id1-->id4((7));
+* `v1` à droite de `A` (gauche de `B`)
-    id2-->id5((2));
-    id2-->id6((5));
+![Après équilibrage](figs/cas2a_droite.png)
-    id3-->id7((10));
-    id3-->id8((6));
+::::
-    id4-->id9((4));
-    id4-->id10(( ));    
+:::
-    style id10 fill:#fff,stroke:#fff
-```
+# Les cas de déséquilibre
+::: columns
+:::: column
+## Cas 2b (symétrique 2a)
+![Après insertion](figs/cas2b_gauche.png)
+::::
+:::: column
+## Cas 2b (symétrique 2a)
+* Comment rééquilibrer?
+. . .
+![Après équilibrage](figs/cas2b_droite.png)
 ::::
 :::
+# Le facteur d'équilibre (balance factor)
+## Définition
 ```
-           *   *
+fe(arbre) = hauteur(droite(arbre)) - hauteur(gauche(arbre))
-        | 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
 ```
+## Valeurs possibles?
-# Exemple de tri par tas (5/13)
+. . .
 ```
-        | 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
+fe = {-1, 0, 1} // arbre AVL
+fe = {-2, 2}    // arbre déséquilibré
 ```
+![Illustration du `fe`](figs/facteur_equilibre.png){width=40%}
+# Algorithme d'insertion
+* Insérer le noeud comme d'habitude.
+* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
+  noeud déséquilibré).
+* Rééquilibrer le noeud si nécessaire.
+## Cas possibles
 ::: columns
 :::: column
-**But:** Transformer l'arbre en tas.
+## Sous-arbre gauche (avant)
-* Recommencer avec `1`.
+```
-* `1 <=> max(1, 12, 7)`.
+fe(P) =  1 
+fe(P) =  0 
+fe(P) = -1 
+```
-```{.mermaid format=pdf width=400 loc=figs/}
+::::
-graph TD;
-    id0((16))-->id1((12));
+:::: column
-    id0-->id2((8));
-    id1-->id3((1));
+## Sous-arbre gauche (après)
-    id1-->id4((7));
-    id2-->id5((2));
+. . .
-    id2-->id6((5));
-    id3-->id7((10));
+```
-    id3-->id8((6));
+=> fe(P) =  0 
-    id4-->id9((4));
+=> fe(P) = -1 
-    id4-->id10(( ));    
+=> fe(P) = -2 // Rééquilibrer P
-    style id10 fill:#fff,stroke:#fff
 ```
 ::::
+:::
+# Algorithme d'insertion
+* Insérer le noeud comme d'habitude.
+* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
+  noeud déséquilibré).
+* Rééquilibrer le noeud si nécessaire.
+## Cas possibles
+::: columns
 :::: column
-**But:** Transformer l'arbre en tas.
+## Sous-arbre droit (avant)
-* Recommencer avec `1`.
+```
-* `1 <=> max(1, 10, 6)`.
+fe(P) =  1 
+fe(P) =  0 
+fe(P) = -1 
+```
-```{.mermaid format=pdf width=400 loc=figs/}
+::::
-graph TD;
-    id0((16))-->id1((12));
+:::: column
-    id0-->id2((8));
-    id1-->id3((10));
+## Sous-arbre droit (après)
-    id1-->id4((7));
-    id2-->id5((2));
+. . .
-    id2-->id6((5));
-    id3-->id7((1));
+```
-    id3-->id8((6));
+=> fe(P) =  0 
-    id4-->id9((4));
+=> fe(P) = +1 
-    id4-->id10(( ));    
+=> fe(P) = +2 // Rééquilibrer P
-    style id10 fill:#fff,stroke:#fff
 ```
 ::::
 :::
+# Rééquilibrage
+## Lien avec les cas vus plus tôt
 ```
-                *        *               *
+fe(P) = -2 && fe(gauche(P)) = -1 => cas 1a
-        | 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
+fe(P) = -2 && fe(gauche(P)) = +1 => cas 2a
+fe(P) = +2 && fe(droite(P)) = -1 => cas 2b
+fe(P) = +2 && fe(droite(P)) = +1 => cas 1b
 ```
-* L'arbre est un tas.
+## Dessiner les différents cas, sur le dessin ci-dessous
+![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
-# Exemple de tri par tas (6/13)
+# La rotation
+## La rotation gauche (5min, matrix)
+![L'arbre de droite devient celui de gauche. Comment?](figs/rotation_gauche_droite.png)
+. . .
+\footnotesize
 ```
-        | 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
+arbre rotation_gauche(arbre P) 
+    si est_non_vide(P)
+        Q = droite(P)
+        droite(P) = gauche(Q)
+        gauche(Q) = P
+        retourne Q
+    retourne P
 ```
-::: columns
+# La rotation en C (1/2)
-:::: column
+## La rotation gauche
-**But:** Trier les tas.
+```
+arbre rotation_gauche(arbre P) 
+    si est_non_vide(P)
+        Q = droite(P)
+        droite(P) = gauche(Q)
+        gauche(Q) = P
+        retourne Q
+    retourne P
+```
-* Échanger la racine, `16` (`max` de l'arbre) avec `4`.
+## Écrire le code C correspondant (5min, matrix)
-* Traiter la racine.
-```{.mermaid format=pdf width=400 loc=figs/}
+1. Structure de données
-graph TD;
+2. Fonction `tree_t rotation_left(tree_t tree)`
-    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
+\footnotesize
+```C
+typedef struct _node {
+    int key;
+    struct _node *left, *right;
+    int bf; // balance factor
+} node;
+typedef node *tree_t;
+```
-**But:** Trier les tas.
+# La rotation en C (2/2)
-* `4 <=> max(4, 12, 8)`.
+\footnotesize
-* `4 <=> max(4, 10, 7)`.
-* `4 <=> max(4, 1, 6)`.
-```{.mermaid format=pdf width=400 loc=figs/}
+```C
-graph TD;
+tree_t rotation_left(tree_t tree) {
-    id0((12))-->id1((10));
+    tree_t subtree = NULL;
-    id0-->id2((8));
+    if (NULL != tree) {
-    id1-->id3((6));
+        subtree = tree->right;
-    id1-->id4((7));
+        tree->right = subtree->left;
-    id2-->id5((2));
+        subtree->left = tree;
-    id2-->id6((5));
+    }
-    id3-->id7((1));
+    return subtree;
-    id3-->id8((4));
+}
 ```
-::::
+. . .
-:::
+* Et la rotation à droite, pseudo-code (5min)?
+. . .
 ```
-        | 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
+arbre rotation_droite(arbre P) 
+    si est_non_vide(P)
+        Q = gauche(P)
+        gauche(P) = droite(Q)
+        droite(Q) = P
+        retourne Q
+    retourne P
 ```
+<!-- ```C
+tree_t rotation_right(tree_t tree) {
+    tree_t subtree = NULL;
+    if (NULL != tree) {
+        subtree = tree->left;
+        tree->left = subtree->right;
+        subtree->right = tree;
+    }
+    return subtree;
+}
+``` -->
+# Exemple de rotation (1/2)
-# Exemple de tri par tas (7/13)
+## Insertion de 9?
-```
+```{.mermaid format=pdf width=400 loc=figs/}
-        | 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
+graph TD;
+    id0((5))-->id1((1));
+    id0-->id2((6));
+    id2-->id3((  ));
+    id2-->id4((8));
+    style id3 fill:#fff,stroke:#fff
 ```
+# Exemple de rotation (2/2)
 ::: columns
 :::: column
-**But:** Trier les tas.
+## Quelle rotation et sur quel noeud (5 ou 6)?
-* É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((5))-->id1((1));
-    id0-->id2((8));
+    id0-->id2((6));
-    id1-->id3((6));
+    id2-->id3((  ));
-    id1-->id4((7));
+    id2-->id4((8));
-    id2-->id5((2));
+    id4-->id5((  ));
-    id2-->id6((5));
+    id4-->id6((9));
-    id3-->id7((1));
+    style id3 fill:#fff,stroke:#fff
-    id3-->id8((  ));
+    style id5 fill:#fff,stroke:#fff
-    style id8 fill:#fff,stroke:#fff
 ```
 ::::
 :::: column
-**But:** Trier les tas.
+. . .
-* `4 <=> max(4, 10, 8)`.
+## Sur le plus jeune évidemment!
-* `4 <=> max(4, 6, 7)`.
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((10))-->id1((7));
+    id0((5))-->id1((1));
    id0-->id2((8));
-    id1-->id3((6));
+    id2-->id3((6));
-    id1-->id4((4));
+    id2-->id4((9));
-    id2-->id5((2));
-    id2-->id6((5));
-    id3-->id7((1));
-    id3-->id8((  ));
-    style id8 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-```
+* Cas `1a/b` *check*!
-        | 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
-```
-# Exemple de tri par tas (8/13)
-```
+# La rotation gauche-droite
-        | 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
-```
+## Là c'est plus difficile (cas 2a/b)
+![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
+# Exercices
+## Faire l'implémentation de la double rotation (pas corrigé, 5min)
+# Exercices
 ::: columns
 :::: column
-**But:** Trier les tas.
+## Insérer 50, ex 10min (matrix)
-* É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((89))-->id1((71));
-    id0-->id2((8));
+    id0-->id2((90));
-    id1-->id3((6));
+    id1-->id3((44));
-    id1-->id4((4));
+    id3-->id4((37));
-    id2-->id5((2));
+    id3-->id5((61));
-    id2-->id6((5));
+    id1-->id6((81))
+    id2-->id7((  ))
+    id2-->id8((100))
+    style id7 fill:#fff,stroke:#fff
 ```
 ::::
 :::: column
-**But:** Trier les tas.
+. . .
-* `1 <=> max(1, 7, 8)`.
+## Où se fait la rotation?
-* `5 <=> max(1, 2, 5)`.
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((8))-->id1((7));
+    id0((89))-->id1((71));
-    id0-->id2((5));
+    id0-->id2((90));
-    id1-->id3((6));
+    id1-->id3((44));
-    id1-->id4((4));
+    id3-->id4((37));
-    id2-->id5((2));
+    id3-->id5((61));
-    id2-->id6((1));
+    id1-->id6((81))
+    id2-->id7((  ))
+    id2-->id8((100))
+    id5-->id9((50))
+    id5-->id10((  ))
+    style id7 fill:#fff,stroke:#fff
+    style id10 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-```
+# Exercices
-        | 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
-```
-# Exemple de tri par tas (9/13)
-```
-        | 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
-```
 ::: columns
 :::: column
-**But:** Trier les tas.
+## Rotation gauche en 44
-* É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((89))-->id1((71));
-    id0-->id2((5));
+    id0-->id2((90));
-    id1-->id3((6));
+    id1-->id3((61));
-    id1-->id4((4));
+    id1-->id10((81));
-    id2-->id5((2));
+    id3-->id4((44));
-    id2-->id6((  ));
+    id3-->id5((  ));
-    style id6 fill:#fff,stroke:#fff
+    id4-->id6((37))
+    id4-->id7((50))
+    id2-->id8((  ))
+    id2-->id9((100))
+    style id5 fill:#fff,stroke:#fff
+    style id8 fill:#fff,stroke:#fff
 ```
 ::::
 :::: column
-**But:** Trier les tas.
+. . .
-* `1 <=> max(1, 7, 5)`.
+## Rotation à droite en 71
-* `1 <=> max(1, 6, 4)`.
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((7))-->id1((6));
+    id0((89))-->id1((61));
-    id0-->id2((5));
+    id0-->id2((90));
-    id1-->id3((1));
+    id1-->id3((44));
-    id1-->id4((4));
+    id1-->id10((71));
-    id2-->id5((2));
+    id3-->id4((37));
-    id2-->id6((  ));
+    id3-->id5((50));
-    style id6 fill:#fff,stroke:#fff
+    id2-->id8((  ));
+    id2-->id9((100));
+    id10-->id11((  ))
+    id10-->id12((81))
+    style id8 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-```
+# Exercice de la mort
-        | 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
-```
-# Exemple de tri par tas (10/13)
-```
+Soit l’arbre AVL suivant:
-        | 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
-```
 ::: columns
 :::: column
-**But:** Trier les tas.
+```{.mermaid format=pdf width=400 loc=figs/}
-* Échanger la racine, `7` (`max` de l'arbre) avec `2`.
-* Traiter la racine.
-```{.mermaid format=pdf width=150 loc=figs/}
 graph TD;
-    id0((2))-->id1((6));
+    id0((60))-->id1((40));
-    id0-->id2((5));
+    id0-->id2((120));
-    id1-->id3((1));
+    id1-->id3((20));
-    id1-->id4((4));
+    id1-->id4((50));
+    id3-->id5((10));
+    id3-->id6((30));
+    id2-->id7((100));
+    id2-->id8((140));
+    id7-->id9((80))
+    id7-->id10((110))
+    id9-->id11((70))
+    id9-->id12((90))
+    id8-->id13((130))
+    id8-->id14((160))
+    id14-->id15((150))
+    id14-->id16((170))
 ```
 ::::
 :::: column
-**But:** Trier les tas.
+1. Montrer les positions des insertions de feuille qui conduiront à un arbre
+   désequilibré.
-* `2 <=> max(2, 6, 5)`.
+2. Donner les facteurs d’equilgaucheibre.
-* `2 <=> max(2, 1, 4)`.
+3. Dessiner et expliquer les modifications de l’arbre lors de l’insertion de la
+   valeur `65`. On mentionnera les modifications des facteurs
-```{.mermaid format=pdf width=150 loc=figs/}
+   d’équilibre.
-graph TD;
-    id0((6))-->id1((4));
-    id0-->id2((5));
-    id1-->id3((1));
-    id1-->id4((2));
-```
 ::::
 :::
-```
+# Encore un petit exercice
-        | 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
-```
-# Exemple de tri par tas (11/13)
+* Insérer les nœuds suivants dans un arbre AVL
 ```
-        | 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
+25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40 
+    | 50 | 55 | 30 | 15
 ```
+## Un à un et le/la premier/ère qui poste la bonne réponse sur matrix a un point
+# Suppression dans un arbre AVL
 ::: columns
 :::: column
-**But:** Trier les tas.
+## Algorithme par problème: supprimer 10
-* Échanger la racine, `6` (`max` de l'arbre) avec `2`.
+```{.mermaid format=pdf width=400 loc=figs/}
-* Traiter la racine.
-```{.mermaid format=pdf width=150 loc=figs/}
 graph TD;
-    id0((2))-->id1((4));
+    id0((8))-->id1((4));
-    id0-->id2((5));
+    id0-->id2((10));
-    id1-->id3((1));
+    id1-->id3((2));
-    id1-->id4((  ));
+    id1-->id4((6));
-    style id4 fill:#fff,stroke:#fff
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((9))
+    id2-->id10((14))
+    id10-->id11((12))
+    id10-->id12((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
 ```
 ::::
 :::: column
-**But:** Trier les tas.
+. . .
-* `2 <=> max(2, 4, 5)`.
+## Algorithme par problème: supprimer 10
-* `2 <=> max(2, 1, 4)`.
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((5))-->id1((4));
+    id0((8))-->id1((4));
-    id0-->id2((2));
+    id0-->id2((12));
-    id1-->id3((1));
+    id1-->id3((2));
-    id1-->id4((  ));
+    id1-->id4((6));
-    style id4 fill:#fff,stroke:#fff
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((9))
+    id2-->id10((14))
+    id10-->id11((  ))
+    id10-->id12((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-```
+# Suppression dans un arbre AVL
-        | 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
-```
-# Exemple de tri par tas (12/13)
-```
-        | 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
-```
 ::: columns
 :::: column
-**But:** Trier les tas.
+## Algorithme par problème: supprimer 8
-* É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((8))-->id1((4));
-    id0-->id2((2));
+    id0-->id2((12));
+    id1-->id3((2));
+    id1-->id4((6));
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((9))
+    id2-->id10((14))
+    id10-->id11((  ))
+    id10-->id12((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
 ```
 ::::
 :::: column
-**But:** Trier les tas.
+. . .
-* `1 <=> max(1, 4, 2)`.
+## Algorithme par problème: rotation de 12
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((4))-->id1((1));
+    id0((9))-->id1((4));
-    id0-->id2((2));
+    id0-->id2((12));
+    id1-->id3((2));
+    id1-->id4((6));
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((  ))
+    id2-->id10((14))
+    id10-->id11((  ))
+    id10-->id12((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id9 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-```
+# Suppression dans un arbre AVL
-        | 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
-```
-# Exemple de tri par tas (13/13)
-```
-        | 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
-```
 ::: columns
 :::: column
-**But:** Trier les tas.
+## Algorithme par problème: rotation de 12
-* É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((9))-->id1((4));
-    id0-->id2(( ));
+    id0-->id2((14));
-    style id2 fill:#fff,stroke:#fff
+    id1-->id3((2));
+    id1-->id4((6));
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((12))
+    id2-->id10((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 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. On supprime comme d'habitude.
+2. On rééquilibre si besoin à l'endroit de la suppression.
-::::
+* Facile non?
-:::
+. . .
-```
+* Plus dur....
-        | 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
-```
-# Exercice (10min)
+::::
-* Trier par tas le tableau
+:::
-```
+# Suppression dans un arbre AVL 2.0
-        | 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
-```
-* Mettez autant de détails que possible.
+::: columns
-* Que constatez-vous?
-* Postez le résultat sur matrix.
-# L'algorithme du tri par tas (1/2)
+:::: column
-\footnotesize
+## Algorithme par problème: suppression de 30
-## Deux étapes
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((50))-->id1((30));
+    id0-->id2((100));
+    id1-->id3((10));
+    id1-->id4((40));
+    id3-->id5((  ));
+    id3-->id6((20))
+    id2-->id7((80))
+    id2-->id8((200))
+    id7-->id9((70))
+    id7-->id10((90))
+    id9-->id11((60))
+    id9-->id12((  ))
+    id8-->id13((  ))
+    id8-->id14((300))
+    style id5 fill:#fff,stroke:#fff
+    style id12 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
+```
-1. Entassement: 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 (15 min, matrix)
+:::: column
 . . .
-```python
+## Algorithme par problème: rotation GD autour de 40
-rien tri_par_tas(tab)
-    entassement(tab)
-    échanger(tab[0], tab[size(tab)-1])
-    pour i de size(tab)-1 à 2 
-        tamisage(tab, 0)
-        échanger(tab[0], tab[i-1])
-rien entassement(tab)
-    pour i de size(tab)/2-1 à 0
-        tamisage(tab, i)
-rien tamisage(tab, i)
+```{.mermaid format=pdf width=400 loc=figs/}
-    ind_max = ind_max(tab, i, gauche(i), droite(i))
+graph TD;
-    si i != ind_max
+    id0((50))-->id1((40));
-        échanger(tab[i], tab[ind_max])
+    id0-->id2((100));
-        tamisage(tab, ind_max)
+    id1-->id3((10));
+    id1-->id4((  ));
+    id3-->id5((  ));
+    id3-->id6((20))
+    id2-->id7((80))
+    id2-->id8((200))
+    id7-->id9((70))
+    id7-->id10((90))
+    id9-->id11((60))
+    id9-->id12((  ))
+    id8-->id13((  ))
+    id8-->id14((300))
+    style id4 fill:#fff,stroke:#fff
+    style id5 fill:#fff,stroke:#fff
+    style id12 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
 ```
-# L'algorithme du tri par tas (2/2)
+::::
-* Fonctions utilitaires
+:::
-    ```python
+# Suppression dans un arbre AVL 2.0
-    entier ind_max(tab, i, g, d)
-        ind_max = i
-        si tab[ind_max] < tab[g] && size(tab) > g
-            ind_max = g
-        si tab[ind_mx] < tab[d] && size(tab) > d
-            ind_max = d
-        retourne ind_max
-    entier gauche(i)
+::: columns
-        retourne 2 * i + 1
-    entier droite(i)
+:::: column
-        retourne 2 * i + 2
-    ```
+## Argl! 50 est déséquilibré!
-<!-- # L'algorithme du tri par tas (3/4)
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((50))-->id1((20));
+    id0-->id2((100));
+    id1-->id3((10));
+    id1-->id4((40));
+    id2-->id7((80))
+    id2-->id8((200))
+    id7-->id9((70))
+    id7-->id10((90))
+    id9-->id11((60))
+    id9-->id12((  ))
+    id8-->id13((  ))
+    id8-->id14((300))
+    style id12 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
+```
-\footnotesize
+::::
-## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
+:::: column
 . . .
-```C 
+## Algorithme par problème: rotation DG autour de 50
-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 (4/4)
-\footnotesize
-## Fonctions utilitaires
-. . .
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((80))-->id1((50));
+    id0-->id2((100));
+    id1-->id3((20));
+    id1-->id4((70));
+    id3-->id5((10));
+    id3-->id6((40));
+    id4-->id9((60))
+    id4-->id10((  ))
+    id2-->id7((90))
+    id2-->id8((200))
+    id8-->id13((  ))
+    id8-->id14((300))
+    style id10 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
+```
-```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;
-}
-``` -->
+:::
-[^2]: Copyright cours de mathématiques pendant trop d'années.
+# Résumé de la suppression
+1. On supprime comme pour un arbre binaire de recherche.
+2. Si un nœud est déséquilibré, on le rééquilibre.
+    * Cette opération peut déséquilibrer un autre nœud.
+3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer.
--- a/slides/cours_19.md
+++ b/slides/cours_19.md
 ---
-title: "Arbres AVL"
+title: "Arbres AVL et arbres quaternaires"
-date: "2024-03-25"
+date: "2025-03-28"
 ---
-# Tri par tas: algorithme
+# Rappel: Algorithme d'insertion
-\footnotesize
+* Insérer le noeud comme d'habitude.
+* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
+  noeud déséquilibré).
+* Rééquilibrer le noeud si nécessaire.
-* Vous souvenez-vous de l'algorithme?
+# Rappel: les cas de déséquilibre
-. . .
+::: columns
-```python
+:::: column
-rien tri_par_tas(tab)
-    entassement(tab)
-    échanger(tab[0], tab[size(tab)-1])
-    pour i de size(tab)-1 à 2 
-        tamisage(tab, 0)
-        échanger(tab[0], tab[i-1])
-rien entassement(tab)
-    pour i de size(tab)/2-1 à 0
-        tamisage(tab, i)
-rien tamisage(tab, i)
-    ind_max = ind_max(tab, i, gauche(i), droite(i))
-    si i != ind_max
-        échanger(tab[i], tab[ind_max])
-        tamisage(tab, ind_max)
-```
+## Cas 1a
+* `u`, `v`, `w` même hauteur.
+* déséquilibre en `B` après insertion dans `u`
-# Un meilleur arbre
+![Après insertion](figs/cas1a_gauche.png)
-* Quelle propriété doit satisfaire un arbre pour que la recherche soit $O(\log_2(N))$?
+::::
-. . .
+:::: column
-* Si on a environ le même nombre de nœuds dans les sous-arbres.
+## Cas 1a
-## Définition
+* Comment rééquilibrer?
-Un arbre binaire est parfaitement équilibré si, pour chaque
+. . .
-nœud, la différence entre les nombres de nœuds des sous-
-arbres gauche et droit vaut au plus 1.
-* Si l'arbre est **parfaitement équilibré**, alors tout ira bien.
+* ramène `u`, `v` `w` à la même hauteur.
-* Quelle est la hauteur (profondeur) d'un arbre parfaitement équilibré?
+* `v` à droite de `A` (gauche de `B`)
-. . .
+![Après équilibrage](figs/cas1a_droite.png)
+::::
-* $O(\log_2(N))$.
+:::
+# Rappel: Les cas de déséquilibre
-# Équilibre parfait ou pas?
 ::: columns
 :::: column
-```{.mermaid format=pdf width=400 loc=figs/}
+## Cas 2a
-graph TD;
-    id0((W))-->id1((B));
+* `h(v1)=h(v2), h(u)=h(w)`.
-    id0-->id8((Y));
+* déséquilibre en `C` après insertion dans `v2`
-    id1-->id2((A));
-    id1-->id9((  ));
+![Après insertion](figs/cas2a_gauche.png)
-    id8-->id10((X));
-    id8-->id11((  ));
-    style id9 fill:#fff,stroke:#fff
-    style id11 fill:#fff,stroke:#fff
-```
 ::::
 :::: column
+## Cas 2a
+* Comment rééquilibrer?
 . . .
-```
+* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
-É
+* `v2` à droite de `B` (gauche de `C`)
-Q
+* `B` à droite de `A` (gauche de `C`)
-U
+* `v1` à droite de `A` (gauche de `B`)
-I
-L
+![Après équilibrage](figs/cas2a_droite.png)
-I
-B
-R
-É
-```
 ::::
 :::
-# Équilibre parfait ou pas?
+# Rappel: Rééquilibrage
-::: columns
+## Rotation simple
-:::: column
+![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
-```{.mermaid format=pdf width=400 loc=figs/}
+# Rappel: La rotation gauche-droite
-graph TD;
-    id0((16))-->id1((10));
-    id0-->id2((19));
-    id1-->id3((8));
-    id1-->id4((12));
-    id4-->id5((11));
-    id4-->id6((  ));
-    id2-->id7((17));
-    id2-->id8((  ));
-    id7-->id9((  ));
-    id7-->id10((18));
-    style id6 fill:#fff,stroke:#fff
-    style id8 fill:#fff,stroke:#fff
-    style id9 fill:#fff,stroke:#fff
-```
-::::
+## Le cas 2a/b
-:::: column
+![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
-. . .
+# Un petit exercice
+* Insérer les nœuds suivants dans un arbre AVL
 ```
-P 
+25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40 
-A
+    | 50 | 55 | 30 | 15
-S 
-É
-Q
-U
-I
-L
-I
-B
-R
-É
 ```
-::::
+```
-:::
-# Arbres AVL
-\footnotesize
-* Quand est-ce qu'on équilibre un arbre?
-. . .
-* A l'insertion/suppression.
-* Maintenir un arbre en état d'équilibre parfait: cher (insertion, suppression).
-* On peut "relaxer" la condition d'équilibre: profondeur (hauteur) au lieu du
-  nombre de nœuds:
-    * La hauteur $\sim\log_2(N)$.
-## Définition
-Un arbre AVL (Adelson-Velskii et Landis) est un arbre binaire de recherche dans
-lequel, pour chaque nœud, la différence de hauteur entre le sous-arbre gauche et droit vaut au plus 1.
-* Relation entre nœuds et hauteur:
-$$
-\log_2(1+N)\leq 1+H\leq 1.44\cdot\log_2(2+N),\quad N=10^5,\ 17\leq H \leq 25.
-$$
-* Permet l'équilibrage en temps constant: insertion/suppression $O(\log_2(N))$.
-# Notation
-* `hg`: hauteur du sous-arbre gauche.
-* `hd`: hauteur du sous-arbre droit.
-* `facteur d'équilibre = fe = hd - hg`
-* Que vaut `fe` si l'arbre est AVL?
-. . .
+```
-* `fe = {-1, 0, 1}`
+# La suppression dans un arbre AVL
+\Huge La suppression dans un arbre AVL
-# AVL ou pas?
+# Suppression dans un arbre AVL
 ::: columns
 :::: column
+## Algorithme par problème: supprimer 10
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((12))-->id1((10));
+    id0((8))-->id1((4));
-    id0-->id2((19));
+    id0-->id2((10));
-    id2-->id3((17));
+    id1-->id3((2));
-    id2-->id4((97));
+    id1-->id4((6));
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((9))
+    id2-->id10((14))
+    id10-->id11((12))
+    id10-->id12((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
 ```
 ::::
@@ -200,31 +147,57 @@ graph TD;
 . . .
-```
+## Algorithme par problème: supprimer 10
-A
-V
+```{.mermaid format=pdf width=400 loc=figs/}
-L
+graph TD;
+    id0((8))-->id1((4));
+    id0-->id2((12));
+    id1-->id3((2));
+    id1-->id4((6));
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((9))
+    id2-->id10((14))
+    id10-->id11((  ))
+    id10-->id12((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-# AVL ou pas?
+# Suppression dans un arbre AVL
 ::: columns
 :::: column
+## Algorithme par problème: supprimer 8
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((12))-->id1((1));
+    id0((8))-->id1((4));
-    id0-->id2((19));
+    id0-->id2((12));
-    id2-->id3((17));
+    id1-->id3((2));
-    id2-->id4((97));
+    id1-->id4((6));
-    id4-->id5((37));
+    id3-->id5((1));
-    id4-->id6((  ));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((9))
+    id2-->id10((14))
+    id10-->id11((  ))
+    id10-->id12((16))
    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
 ```
 ::::
@@ -233,36 +206,54 @@ graph TD;
 . . .
-```
+## Algorithme par problème: rotation de 12
-P
-A
-S
-A
+```{.mermaid format=pdf width=400 loc=figs/}
-V
+graph TD;
-L
+    id0((9))-->id1((4));
+    id0-->id2((12));
+    id1-->id3((2));
+    id1-->id4((6));
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((  ))
+    id2-->id10((14))
+    id10-->id11((  ))
+    id10-->id12((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id9 fill:#fff,stroke:#fff
+    style id11 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-# Insertion dans un arbre AVL (1/N)
+# Suppression dans un arbre AVL
-1. On part d'un arbre AVL.
-2. On insère un nouvel élément.
 ::: columns
 :::: column
-* `hd ? hg`.
+## Algorithme par problème: rotation de 12
-* Insertion de `4`?
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((12))-->id1((1));
+    id0((9))-->id1((4));
-    id0-->id2((19));
+    id0-->id2((14));
+    id1-->id3((2));
+    id1-->id4((6));
+    id3-->id5((1));
+    id3-->id6((  ))
+    id4-->id7((  ))
+    id4-->id8((7))
+    id2-->id9((12))
+    id2-->id10((16))
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
 ```
 ::::
@@ -271,42 +262,46 @@ graph TD;
 . . .
-* `hd = hg`
+1. On supprime comme d'habitude.
+2. On rééquilibre si besoin à l'endroit de la suppression.
+* Facile non?
-```{.mermaid format=pdf width=400 loc=figs/}
+. . .
-graph TD;
-    id0((12))-->id1((1));
-    id0-->id2((19));
-    id1-->id4((  ));
-    id1-->id5((4));
-    style id4 fill:#fff,stroke:#fff
-```
-* `fe = -1`
+* Plus dur....
 ::::
 :::
-# Insertion dans un arbre AVL (2/N)
+# Suppression dans un arbre AVL 2.0
-1. On part d'un arbre AVL.
-2. On insère un nouvel élément.
 ::: columns
 :::: column
-* `hd ? hg`.
+## Algorithme par problème: suppression de 30
-* Insertion de `4`?
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((12))-->id1((1));
+    id0((50))-->id1((30));
-    id0-->id2((19));
+    id0-->id2((100));
-    id2-->id3((18));
+    id1-->id3((10));
-    id2-->id4((  ));
+    id1-->id4((40));
-    style id4 fill:#fff,stroke:#fff
+    id3-->id5((  ));
+    id3-->id6((20))
+    id2-->id7((80))
+    id2-->id8((200))
+    id7-->id9((70))
+    id7-->id10((90))
+    id9-->id11((60))
+    id9-->id12((  ))
+    id8-->id13((  ))
+    id8-->id14((300))
+    style id5 fill:#fff,stroke:#fff
+    style id12 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
 ```
 ::::
@@ -315,51 +310,58 @@ graph TD;
 . . .
-* `hd < hg`
+## Algorithme par problème: rotation GD autour de 40
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((12))-->id1((1));
+    id0((50))-->id1((40));
-    id0-->id2((19));
+    id0-->id2((100));
-    id2-->id3((18));
+    id1-->id3((10));
-    id2-->id4((  ));
+    id1-->id4((  ));
-    id1-->id5((  ));
+    id3-->id5((  ));
-    id1-->id6((4));
+    id3-->id6((20))
+    id2-->id7((80))
+    id2-->id8((200))
+    id7-->id9((70))
+    id7-->id10((90))
+    id9-->id11((60))
+    id9-->id12((  ))
+    id8-->id13((  ))
+    id8-->id14((300))
    style id4 fill:#fff,stroke:#fff
    style id5 fill:#fff,stroke:#fff
+    style id12 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
 ```
-* `fe = 0`
 ::::
 :::
-# Insertion dans un arbre AVL (3/N)
+# Suppression dans un arbre AVL 2.0
-\footnotesize
-1. On part d'un arbre AVL.
-2. On insère un nouvel élément.
 ::: columns
 :::: column
-* `hd ? hg`.
+## Argl! 50 est déséquilibré!
-* Insertion de `4`?
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((12))-->id1((1));
+    id0((50))-->id1((20));
-    id0-->id2((19));
+    id0-->id2((100));
-    id1-->id3((  ));
+    id1-->id3((10));
-    id1-->id4((6));
+    id1-->id4((40));
-    id2-->id5((  ));
+    id2-->id7((80))
-    id2-->id6((  ));
+    id2-->id8((200))
-    style id3 fill:#fff,stroke:#fff
+    id7-->id9((70))
-    style id5 fill:#fff,stroke:#fff
+    id7-->id10((90))
-    style id6 fill:#fff,stroke:#fff
+    id9-->id11((60))
+    id9-->id12((  ))
+    id8-->id13((  ))
+    id8-->id14((300))
+    style id12 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
 ```
 ::::
@@ -368,868 +370,526 @@ graph TD;
 . . .
-* `hd < hg`
+## Algorithme par problème: rotation DG autour de 50
 ```{.mermaid format=pdf width=400 loc=figs/}
 graph TD;
-    id0((12))-->id1((1));
+    id0((80))-->id1((50));
-    id0-->id2((19));
+    id0-->id2((100));
-    id1-->id3((  ));
+    id1-->id3((20));
-    id1-->id4((6));
+    id1-->id4((70));
-    id4-->id5((4));
+    id3-->id5((10));
-    id4-->id6((  ));
+    id3-->id6((40));
-    id2-->id7((  ));
+    id4-->id9((60))
-    id2-->id8((  ));
+    id4-->id10((  ))
-    style id3 fill:#fff,stroke:#fff
+    id2-->id7((90))
-    style id6 fill:#fff,stroke:#fff
+    id2-->id8((200))
-    style id7 fill:#fff,stroke:#fff
+    id8-->id13((  ))
-    style id8 fill:#fff,stroke:#fff
+    id8-->id14((300))
-```
+    style id10 fill:#fff,stroke:#fff
+    style id13 fill:#fff,stroke:#fff
-::::
+```
-:::
-**Déséquilibre!** Que vaut `fe`?
-. . .
-* `fe = 2`
-# Les cas de déséquilibre
-::: columns
-:::: column
-## Cas 1a
-* `u`, `v`, `w` même hauteur.
-* déséquilibre en `B` après insertion dans `u`
-![Après insertion](figs/cas1a_gauche.png)
 ::::
-:::: column
+:::
-## Cas 1a
-* Comment rééquilibrer?
-. . .
-* ramène `u`, `v` `w` à la même hauteur.
-* `v` à droite de `A` (gauche de `B`)
-![Après équilibrage](figs/cas1a_droite.png)
+# Résumé de la suppression
-::::
+1. On supprime comme pour un arbre binaire de recherche.
+2. Si un nœud est déséquilibré, on le rééquilibre.
+    * Cette opération peut déséquilibrer un autre nœud sur le chemin menant au noeud supprimé.
+3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer en remontant le chemin.
-:::
-# Les cas de déséquilibre
+# Les arbres quaternaires
+\Huge Les arbres quaternaires
-::: columns
-:::: column
+# Les arbres quaternaires
-## Cas 1b (symétrique 1a)
+## Définition
-![Après insertion](figs/cas1b_gauche.png)
+Arbre dont chaque nœud a 4 enfants ou aucun. 
-::::
+![Un exemple d'arbre quaternaire.](figs/quad_ex.svg)
-:::: column
+# Les arbres quaternaires
-## Cas 1b (symétrique 1a)
+## Cas d'utilisation
-* Comment rééquilibrer?
+Typiquement utilisés pour représenter des données bidimensionnelles.
-. . .
+Son équivalent tri-dimensionnel est l'octree (chaque nœud a 8 enfants ou aucun).
-![Après équilibrage](figs/cas1b_droite.png)
+## Cas d'utilisation: images
-::::
+* Stockage: compression.
+* Transformations: symétries, rotations, etc.
-:::
+## Cas d'utilisation: simulation
-# Les cas de déséquilibre
+* Indexation spatiale.
+* Détection de collisions.
+* Simulation de galaxies (algorithme de Barnes-Hut).
+# Exemple de compression
 ::: columns
-:::: column
+:::: {.column width=30%}
-## Cas 2a
-* `h(v1)=h(v2), h(u)=h(w)`.
+## Comment représenter l'image
-* déséquilibre en `C` après insertion dans `v2`
-![Après insertion](figs/cas2a_gauche.png)
+![Image noir/blanc.](figs/board_blacked_parts.svg)
 ::::
-:::: column
+:::: {.column width=70%}
-## Cas 2a
-* Comment rééquilibrer?
+## Sous la forme d'un arbre quaternaire?
 . . .
-* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
+![L'arbre quaternaire correspondant.](figs/quad_img.svg)
-* `v2` à droite de `B` (gauche de `C`)
-* `B` à droite de `A` (gauche de `C`)
-* `v1` à droite de `A` (gauche de `B`)
-![Après équilibrage](figs/cas2a_droite.png)
-::::
-:::
-# Les cas de déséquilibre
-::: columns
-:::: column
-## Cas 2b (symétrique 2a)
-![Après insertion](figs/cas2b_gauche.png)
-::::
+**Économie?**
-:::: column
-## Cas 2b (symétrique 2a)
-* Comment rééquilibrer?
 . . .
-![Après équilibrage](figs/cas2b_droite.png)
+Image 64 pixels, arbre 25 nœuds.
 ::::
 :::
-# Le facteur d'équilibre (balance factor)
-## Définition
+# Structure de données
-```
+::: columns
-fe(arbre) = hauteur(droite(arbre)) - hauteur(gauche(arbre))
-```
-## Valeurs possibles?
+:::: {.column width=50%}
+## Pseudo-code?
 . . .
+```python
+struct node
+    info
+    node sup_gauche, sup_droit,
+         inf_gauche, inf_droit
 ```
-fe = {-1, 0, 1} // arbre AVL
-fe = {-2, 2}    // arbre déséquilibré
-```
-![Illustration du `fe`](figs/facteur_equilibre.png){width=40%}
-# Algorithme d'insertion
+![Un nœud d'arbre quaternaire.](figs/quad_struct.svg)
-* Insérer le noeud comme d'habitude.
+::::
-* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
-  noeud déséquilibré).
-* Rééquilibrer le noeud si nécessaire.
-## Cas possibles
-::: columns
+:::: {.column width=50%}
-:::: column
+## En C?
-## Sous-arbre gauche (avant)
+. . .
+```C
+struct _node {
+    int info;
+    struct _node *sup_left;
+    struct _node *sup_right;
+    struct _node *inf_left;
+    struct _node *inf_right;
+};
 ```
-fe(P) =  1 
-fe(P) =  0 
-fe(P) = -1 
-```
-::::
-:::: column
-## Sous-arbre gauche (après)
+* Pourquoi le `*` est important?
 . . .
-```
+* Type récursif => taille inconnue à la compilation.
-=> fe(P) =  0 
-=> fe(P) = -1 
-=> fe(P) = -2 // Rééquilibrer P
-```
 ::::
 :::
-# Algorithme d'insertion
+# Une fonctionnalité simple
-* Insérer le noeud comme d'habitude.
+\footnotesize
-* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
-  noeud déséquilibré).
-* Rééquilibrer le noeud si nécessaire.
-## Cas possibles
-::: columns
-:::: column
+## La fonction `est_feuille(noeud)`
-## Sous-arbre droit (avant)
+* Problème avec cette implémentation?
+```python
+bool est_feuille(noeud) 
+    retourne
+        est_vide(sup_gauche(noeud)) &&
+        est_vide(sup_droit(noeud))  &&
+        est_vide(inf_gauche(noeud)) &&
+        est_vide(inf_droit(noeud))
 ```
-fe(P) =  1 
-fe(P) =  0 
-fe(P) = -1 
-```
-::::
-:::: column
+. . .
-## Sous-arbre droit (après)
+* Inutile d'avoir 4 conditions (soit 4 enfants soit aucun!)
+* Facile d'en oublier un!
+* Comment changer la structure pour que ça soit moins terrible?
 . . .
+```python
+struct node
+    info
+    node enfant[4]
 ```
-=> fe(P) =  0 
-=> fe(P) = +1 
-=> fe(P) = +2 // Rééquilibrer P
-```
-::::
-:::
+# Structure de données
-# Rééquilibrage
+## En C?
-## Lien avec les cas vus plus tôt
+. . .
+```C 
+typedef struct _node {
+    int info;
+    struct _node *child[4];
+} node;
 ```
-fe(P) = -2 && fe(gauche(P)) = -1 => cas 1a
-fe(P) = -2 && fe(gauche(P)) = +1 => cas 2a
-fe(P) = +2 && fe(droite(P)) = -1 => cas 2b
+## Fonction `is_leaf(node *tree)`?
-fe(P) = +2 && fe(droite(P)) = +1 => cas 1b
-```
-## Dessiner les différents cas, sur le dessin ci-dessous
+. . .
-![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
+```C 
+bool is_leaf(node *tree) {
+    return (NULL == tree->child[0]); // only first matters
+}
+```
-# La rotation
+# Problème à résoudre
-## La rotation gauche (5min, matrix)
+* Construire un arbre quaternaire à partir d'une image:
+    * Créer l'arbre (allouer la mémoire pour tous les nœuds)
+    * Remplir l'arbre avec les valeurs des pixels
+* Compression de l'image:
+    * Si les pixels sont les mêmes dans le quadrant on supprime le sous-arbre (sans perte)
+    * Si les pixels ne dévient pas trop, on supprime le quadrant (avec perte)
-![L'arbre de droite devient celui de gauche. Comment?](figs/rotation_gauche_droite.png)
+# Création de l'arbre
+## Comment créer un arbre de profondeur `prof` (3min)?
 . . .
-\footnotesize
+```python
-```
+arbre creer_arbre(prof)
-arbre rotation_gauche(arbre P) 
+    n = nouveau_noeud() # alloue la mémoire
-    si est_non_vide(P)
+    si prof > 0
-        Q = droite(P)
+        pour i = 0 à 3
-        droite(P) = gauche(Q)
+            n.enfant[i] = creer_arbre(prof-1)
-        gauche(Q) = P
+    retourne n
-        retourne Q
-    retourne P
 ```
-# La rotation en C (1/2)
+## En `C` (3 min, matrix)?
-## La rotation gauche
+. . .
-```
+```C
-arbre rotation_gauche(arbre P) 
+node *qt_create(int depth) {
-    si est_non_vide(P)
+    node *n = calloc(1, sizeof(node));
-        Q = droite(P)
+    if (depth > 0) {
-        droite(P) = gauche(Q)
+        for (int i = 0; i < 4; ++i) {
-        gauche(Q) = P
+            n->child[i] = qt_create(depth-1);
-        retourne Q
+        }
-    retourne P
+    }
+    return n;
+}
 ```
-## Écrire le code C correspondant (5min, matrix)
+# Le nombre de nœuds?
-1. Structure de données
+## Comment implémenter la fonction (pseudo-code, 5min, matrix)?
-2. Fonction `tree_t rotation_left(tree_t tree)`
 . . .
-\footnotesize
 ```C
-typedef struct _node {
+entier nombre_nœuds(arbre)
-    int key;
+    si est_feuille(arbre)
-    struct _node *left, *right;
+        retourne 1
-    int bf; // balance factor
+    sinon
-} node;
+        somme = 1
-typedef node *tree_t;
+        pour i de 0 à 3
+            somme += nombre_nœuds(arbre.enfant[i])
+        retourne somme
 ```
-# La rotation en C (2/2)
+# Le nombre de nœuds?
-\footnotesize
+## Comment implémenter la fonction en C (3min, matrix)?
+. . .
 ```C
-tree_t rotation_left(tree_t tree) {
+int size(node *qt) {
-    tree_t subtree = NULL;
+    if (is_leaf(qt)) {
-    if (NULL != tree) {
+        return 1;
-        subtree = tree->right;
+    } else {
-        tree->right = subtree->left;
+        int sum = 1;
-        subtree->left = tree;
+        for (int i = 0; i < 4; ++i) {
+            sum += size(qt->child[i]);
+        }
+        return sum;
    }
-    return subtree;
 }
 ```
-. . .
+# La profondeur en C?
-* Et la rotation à droite, pseudo-code (5min)?
+## Implémentation (5min, matrix)
 . . .
-```
+\footnotesize
-arbre rotation_droite(arbre P) 
-    si est_non_vide(P)
-        Q = gauche(P)
-        gauche(P) = droite(Q)
-        droite(Q) = P
-        retourne Q
-    retourne P
-```
-<!-- ```C
+```C
-tree_t rotation_right(tree_t tree) {
+int max(int x, int y) {
-    tree_t subtree = NULL;
+   return  (x >= y ? x : y);
-    if (NULL != tree) {
+}
-        subtree = tree->left;
+int max_depth(int depths[4]) {
-        tree->left = subtree->right;
+    int m = depths[0];
-        subtree->right = tree;
+    for (int i = 1; i < 4; ++i) {
+        m = max(m, depths[i]);
+    }
+    return m;
+}
+int depth(node *qt) {
+    int depths[] = {0, 0, 0, 0};
+    if (is_leaf(qt)) {
+        return 0;
+    } else {
+        for (int i = 0; i < 4; ++i) {
+            depths[i] = depth(qt->child[i]);
+        }
+        return 1 + max_depth(depths);
    }
-    return subtree;
 }
-``` -->
-# Exemple de rotation (1/2)
-## Insertion de 9?
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((5))-->id1((1));
-    id0-->id2((6));
-    id2-->id3((  ));
-    id2-->id4((8));
-    style id3 fill:#fff,stroke:#fff
 ```
-# Exemple de rotation (2/2)
+# Fonctions utiles (1/4)
-::: columns
-:::: column
+## Comment remplir un arbre depuis une matrice?
-## Quelle rotation et sur quel noeud (5 ou 6)?
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((5))-->id1((1));
-    id0-->id2((6));
-    id2-->id3((  ));
-    id2-->id4((8));
-    id4-->id5((  ));
-    id4-->id6((9));
-    style id3 fill:#fff,stroke:#fff
-    style id5 fill:#fff,stroke:#fff
 ```
+   SG=0  |  SD=1
-::::
+ 21 | 12 | 4 |  4
+  9 |  7 | 4 |  4
-:::: column
+-----------------
+  1 |  1 | 0 | 31
-. . .
+  1 |  1 | 3 | 27
+   IG=2  |  ID=3
-## Sur le plus jeune évidemment!
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((5))-->id1((1));
-    id0-->id2((8));
-    id2-->id3((6));
-    id2-->id4((9));
 ```
-::::
+## Quel arbre cela représente?
-:::
-* Cas `1a/b` *check*!
-# La rotation gauche-droite
+. . .
-## Là c'est plus difficile (cas 2a/b)
-![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
-# Exercices
+![L'arbre correspondant](figs/quad_img_simple.svg)
-## Faire l'implémentation de la double rotation (pas corrigé, 5min)
+# Fonctions utiles (2/4)
-# Exercices
+* On veut transférer la valeur d'une case ligne/colonne dans une feuille.
+* Comment?
 ::: columns
-:::: column
+:::: {.column width=40%}
-## Insérer 50, ex 10min (matrix)
+## Soit `ligne=2`, `colonne=3`
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((89))-->id1((71));
-    id0-->id2((90));
-    id1-->id3((44));
-    id3-->id4((37));
-    id3-->id5((61));
-    id1-->id6((81))
-    id2-->id7((  ))
-    id2-->id8((100))
-    style id7 fill:#fff,stroke:#fff
 ```
+   SG=0  |  SD=1
-::::
+ 21 | 12 | 4 |  4
+  9 |  7 | 4 |  4
-:::: column
+-----------------
+  1 |  1 | 0 | 31
-. . .
+  1 |  1 | 3 | 27
+   IG=2  |  ID=3
-## Où se fait la rotation?
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((89))-->id1((71));
-    id0-->id2((90));
-    id1-->id3((44));
-    id3-->id4((37));
-    id3-->id5((61));
-    id1-->id6((81))
-    id2-->id7((  ))
-    id2-->id8((100))
-    id5-->id9((50))
-    id5-->id10((  ))
-    style id7 fill:#fff,stroke:#fff
-    style id10 fill:#fff,stroke:#fff
 ```
 ::::
-:::
+:::: {.column width=70%}
-# Exercices
-::: columns
+## Trouver un algorithme
-:::: column
+![Déterminer un algorithme.](figs/quad_img_simple.svg)
-## Rotation gauche en 44
+* Quelle feuille pour 31 (`li=2`, `co=3`)?
+* Plus important: quel chemin?
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((89))-->id1((71));
-    id0-->id2((90));
-    id1-->id3((61));
-    id1-->id10((81));
-    id3-->id4((44));
-    id3-->id5((  ));
-    id4-->id6((37))
-    id4-->id7((50))
-    id2-->id8((  ))
-    id2-->id9((100))
-    style id5 fill:#fff,stroke:#fff
-    style id8 fill:#fff,stroke:#fff
-```
-::::
-:::: column
 . . .
-## Rotation à droite en 71
+* `co -> G/D`, `li -> S/I`,
+* `2 * (li / 2) + co / 2 -> 2 * 1 + 1 = 3`
-```{.mermaid format=pdf width=400 loc=figs/}
+* `2 * ((li % 2) / 1) + (co % 2) / 1 -> 2 * 0 + 1 = 1`
-graph TD;
+* Comment généraliser?
-    id0((89))-->id1((61));
-    id0-->id2((90));
-    id1-->id3((44));
-    id1-->id10((71));
-    id3-->id4((37));
-    id3-->id5((50));
-    id2-->id8((  ));
-    id2-->id9((100));
-    id10-->id11((  ))
-    id10-->id12((81))
-    style id8 fill:#fff,stroke:#fff
-    style id11 fill:#fff,stroke:#fff
-```
 ::::
 :::
-# Exercice de la mort
+# Fonctions utiles (3/4)
-Soit l’arbre AVL suivant:
 ::: columns
-:::: column
+:::: {.column width=40%}
-```{.mermaid format=pdf width=400 loc=figs/}
+## Soit `ligne=2`, `colonne=3`
-graph TD;
-    id0((60))-->id1((40));
-    id0-->id2((120));
-    id1-->id3((20));
-    id1-->id4((50));
-    id3-->id5((10));
-    id3-->id6((30));
-    id2-->id7((100));
-    id2-->id8((140));
-    id7-->id9((80))
-    id7-->id10((110))
-    id9-->id11((70))
-    id9-->id12((90))
-    id8-->id13((130))
-    id8-->id14((160))
-    id14-->id15((150))
-    id14-->id16((170))
-```
-::::
-:::: column
-1. Montrer les positions des insertions de feuille qui conduiront à un arbre
-   désequilibré.
-2. Donner les facteurs d’equilgaucheibre.
-3. Dessiner et expliquer les modifications de l’arbre lors de l’insertion de la
-   valeur `65`. On mentionnera les modifications des facteurs
-   d’équilibre.
-::::
-:::
-# Encore un petit exercice
-* Insérer les nœuds suivants dans un arbre AVL
 ```
-25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40 
+   SG=0  |  SD=1
-    | 50 | 55 | 30 | 15
+ 21 | 12 | 4 |  4
+  9 |  7 | 4 |  4
+-----------------
+  1 |  1 | 0 | 31
+  1 |  1 | 3 | 27
+   IG=2  |  ID=3
 ```
-## Un à un et le/la premier/ère qui poste la bonne réponse sur matrix a un point
+::::
-# Suppression dans un arbre AVL
-::: columns
-:::: column
-## Algorithme par problème: supprimer 10
+:::: {.column width=70%}
-```{.mermaid format=pdf width=400 loc=figs/}
+## Trouver un algorithme (prendre plusieurs exemples, 15min, matrix)
-graph TD;
-    id0((8))-->id1((4));
-    id0-->id2((10));
-    id1-->id3((2));
-    id1-->id4((6));
-    id3-->id5((1));
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((9))
-    id2-->id10((14))
-    id10-->id11((12))
-    id10-->id12((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-```
-::::
+![Déterminer un algorithme.](figs/quad_img_simple.svg)
-:::: column
+* Comment généraliser?
 . . .
-## Algorithme par problème: supprimer 10
+```C
+noeud position(li, co, arbre)
-```{.mermaid format=pdf width=400 loc=figs/}
+    d = profondeur(arbre);
-graph TD;
+    tant_que (d >= 1)
-    id0((8))-->id1((4));
+        index = 2 * ((li % 2^d) / 2^(d-1)) +
-    id0-->id2((12));
+            (col % 2^d) / 2^(d-1)
-    id1-->id3((2));
+        arbre = arbre.enfant[index]
-    id1-->id4((6));
+        d -= 1
-    id3-->id5((1));
+    retourne arbre
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((9))
-    id2-->id10((14))
-    id10-->id11((  ))
-    id10-->id12((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-    style id11 fill:#fff,stroke:#fff
 ```
 ::::
 :::
-# Suppression dans un arbre AVL
+# Fonctions utiles (4/4)
-::: columns
-:::: column
+\footnotesize
-## Algorithme par problème: supprimer 8
+## Pseudo-code
-```{.mermaid format=pdf width=400 loc=figs/}
+```C
-graph TD;
+noeud position(li, co, arbre)
-    id0((8))-->id1((4));
+    d = profondeur(arbre);
-    id0-->id2((12));
+    tant_que (d >= 1)
-    id1-->id3((2));
+        index = 2 * ((li % 2^d) / 2^(d-1)) +
-    id1-->id4((6));
+            (col % 2^d) / 2^(d-1)
-    id3-->id5((1));
+        arbre = arbre.enfant[index]
-    id3-->id6((  ))
+        d -= 1
-    id4-->id7((  ))
+    retourne arbre
-    id4-->id8((7))
-    id2-->id9((9))
-    id2-->id10((14))
-    id10-->id11((  ))
-    id10-->id12((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-    style id11 fill:#fff,stroke:#fff
 ```
-::::
+## Écrire le code `C` correspondant (5min, matrix)
-:::: column
+```C
-. . .
-## Algorithme par problème: rotation de 12
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((9))-->id1((4));
-    id0-->id2((12));
-    id1-->id3((2));
-    id1-->id4((6));
-    id3-->id5((1));
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((  ))
-    id2-->id10((14))
-    id10-->id11((  ))
-    id10-->id12((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-    style id9 fill:#fff,stroke:#fff
-    style id11 fill:#fff,stroke:#fff
-```
-::::
-:::
-# Suppression dans un arbre AVL
-::: columns
-:::: column
-## Algorithme par problème: rotation de 12
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((9))-->id1((4));
-    id0-->id2((14));
-    id1-->id3((2));
-    id1-->id4((6));
-    id3-->id5((1));
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((12))
-    id2-->id10((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-```
-::::
-:::: column
+```
-. . .
-1. On supprime comme d'habitude.
+# Remplir l'arbre
-2. On rééquilibre si besoin à l'endroit de la suppression.
-* Facile non?
+## A partir d'une matrice (pseudo-code, 5min, matrix)?
 . . .
-* Plus dur....
+```C
+arbre matrice_vers_arbre(matrice)
-::::
+    arbre = creer_arbre(profondeur)
+    pour li de 0 à nb_lignes(matrice)
-:::
+        pour co de 0 à nb_colonnes(matrice)
+            noeud = position(li, co, arbre)
-# Suppression dans un arbre AVL 2.0
+            noeud.info = matrice[co][li]
+    retourne arbre
-::: columns
-:::: column
-## Algorithme par problème: suppression de 30
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((50))-->id1((30));
-    id0-->id2((100));
-    id1-->id3((10));
-    id1-->id4((40));
-    id3-->id5((  ));
-    id3-->id6((20))
-    id2-->id7((80))
-    id2-->id8((200))
-    id7-->id9((70))
-    id7-->id10((90))
-    id9-->id11((60))
-    id9-->id12((  ))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id5 fill:#fff,stroke:#fff
-    style id12 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
 ```
-::::
+. . .
-:::: column
+## A partir d'une matrice (C, 5min, matrix)?
 . . .
-## Algorithme par problème: rotation GD autour de 40
+\footnotesize
-```{.mermaid format=pdf width=400 loc=figs/}
+```C
-graph TD;
+node *matrix_to_qt(int nb_li, int nb_co, int matrix[nb_li][nb_co], int depth) {
-    id0((50))-->id1((40));
+    node *qt = qt_create(depth);
-    id0-->id2((100));
+    for (int li = 0; li < nb_li; ++li) {
-    id1-->id3((10));
+        for (int co = 0; co < nb_co; ++co) {
-    id1-->id4((  ));
+            node *current = position(li, co, qt);
-    id3-->id5((  ));
+            current->info = matrix[li][co];
-    id3-->id6((20))
+        }
-    id2-->id7((80))
+    }
-    id2-->id8((200))
+    return qt;
-    id7-->id9((70))
+}
-    id7-->id10((90))
-    id9-->id11((60))
-    id9-->id12((  ))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id4 fill:#fff,stroke:#fff
-    style id5 fill:#fff,stroke:#fff
-    style id12 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
 ```
-::::
-:::
-# Suppression dans un arbre AVL 2.0
+# Remplir la matrice
-::: columns
+## A partir de l'arbre (pseudo-code, 3min, matrix)?
-:::: column
+. . .
-## Argl! 50 est déséquilibré!
+\footnotesize
-```{.mermaid format=pdf width=400 loc=figs/}
+```C
-graph TD;
+matrice arbre_vers_matrice(arbre)
-    id0((50))-->id1((20));
+    matrice = creer_matrice(nb_lignes(arbre), nb_colonnes(arbre))
-    id0-->id2((100));
+    pour li de 0 à nb_lignes(matrice)
-    id1-->id3((10));
+        pour co de 0 à nb_colonnes(matrice)
-    id1-->id4((40));
+            noeud = position(li, co, arbre)
-    id2-->id7((80))
+            matrice[co][li] = noeud.info
-    id2-->id8((200))
+    retourne matrice
-    id7-->id9((70))
-    id7-->id10((90))
-    id9-->id11((60))
-    id9-->id12((  ))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id12 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
 ```
-::::
+. . .
-:::: column
+## A partir de l'arbre (C, 3min, matrix)?
 . . .
-## Algorithme par problème: rotation DG autour de 50
+\footnotesize
-```{.mermaid format=pdf width=400 loc=figs/}
+```C
-graph TD;
+void qt_to_matrix(node *qt, int nb_li, int nb_co, int matrix[nb_li][nb_co]) {
-    id0((80))-->id1((50));
+    for (int li = 0; li < nb_li; ++li) {
-    id0-->id2((100));
+        for (int co = 0; co < nb_co; ++co) {
-    id1-->id3((20));
+            node *current = position(li, co, qt);
-    id1-->id4((70));
+            matrix[li][co] = current->info;
-    id3-->id5((10));
+        }
-    id3-->id6((40));
+    }
-    id4-->id9((60))
+}
-    id4-->id10((  ))
-    id2-->id7((90))
-    id2-->id8((200))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id10 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
 ```
-::::
-:::
-# Résumé de la suppression
-1. On supprime comme pour un arbre binaire de recherche.
-2. Si un nœud est déséquilibré, on le rééquilibre.
-    * Cette opération peut déséquilibrer un autre nœud.
-3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer.
--- a/slides/cours_2.md
+++ b/slides/cours_2.md
 ---
-title: "Introduction aux algorithmes"
+title: "Introduction aux algorithmes II"
-date: "2023-09-26"
+date: "2024-09-23"
 ---
 # Rappel

--- a/slides/cours_20.md
+++ b/slides/cours_20.md
 ---
-title: "Arbres AVL et arbres quaternaires"
+title: "Arbres quaternaires"
-date: "2024-04-09"
+date: "2025-04-04"
 ---
-# Rappel: Algorithme d'insertion
+# Rappel sur les arbres quaternaires
-* Insérer le noeud comme d'habitude.
+## Définition?
-* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
-  noeud déséquilibré).
-* Rééquilibrer le noeud si nécessaire.
-# Rappel: les cas de déséquilibre
+. . .
-::: columns
-:::: column
+* Arbre dont chaque nœud a 4 enfants ou aucun. 
-## Cas 1a
+## Utilisation dans ce cours?
-* `u`, `v`, `w` même hauteur.
+. . .
-* déséquilibre en `B` après insertion dans `u`
-![Après insertion](figs/cas1a_gauche.png)
+* Stockage/compression d'image
+* Chaque pixel correspond à une feuille
+* Des portions de l'image peuvent être compressées sans/avec perte
-::::
-:::: column
-## Cas 1a
+# Transformations avec un arbre quaternaire
-* Comment rééquilibrer?
+## A faire
-. . .
+* Symétrie axiale (horizontale/verticale).
+* Rotation quart de cercle (gauche/droite).
+* Compression.
-* ramène `u`, `v` `w` à la même hauteur.
+# La symétrie verticale
-* `v` à droite de `A` (gauche de `B`)
-![Après équilibrage](figs/cas1a_droite.png)
+## Que donne la symétrie verticale de
-::::
+```
+   SG=0  |  SD=1
+ 21 | 12 | 4 |  4
+  9 |  7 | 4 |  4
+-----------------
+  1 |  1 | 0 | 31
+  1 |  1 | 3 | 27
+   IG=2  |  ID=3
+```
-:::
+. . .
-# Rappel: Les cas de déséquilibre
+```
+   SG=0  |  SD=1
+  4 |  4 | 12 | 21
+  4 |  4 |  7 |  9
+------------------
+ 31 |  0 |  1 |  1
+ 27 |  3 |  1 |  1
+   IG=2  |  ID=3
+```
+# La symétrie d'axe vertical
-::: columns
+## Comment faire sur une matrice (3min, matrix)?
-:::: column
+. . .
-## Cas 2a
+\footnotesize
-* `h(v1)=h(v2), h(u)=h(w)`.
+```C
-* déséquilibre en `C` après insertion dans `v2`
+matrice symétrie(matrice)
+    pour i de 0 à nb_lignes(matrice)
+        pour j de 0 à nb_colonnes(matrice)/2
+            échanger(matrice[i][j], matrice[i][nb_colonnes(matrice)-1-j])
+    retourne matrice
+```
-![Après insertion](figs/cas2a_gauche.png)
+# La symétrie d'axe vertical
-::::
+## Comment faire sur un arbre?
-:::: column
+* Faire un dessin de l'arbre avant/après (5min, matrix)
-## Cas 2a
+    ```
+       SG=0  |  SD=1        SG=0  |  SD=1        
+     21 | 12 | 4 |  4       4 | 4 | 12 | 21
+      9 |  7 | 4 |  4       4 | 4 |  7 |  9
+    -----------------  =>  ----------------
+      1 |  1 | 0 | 31      31 | 0 |  1 |  1
+      1 |  1 | 3 | 27      27 | 3 |  1 |  1
+       IG=2  |  ID=3        IG=2  |  ID=3
+    ```
-* Comment rééquilibrer?
+* Écrire le pseudo-code (3min, matrix)
 . . .
-* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
+\footnotesize
-* `v2` à droite de `B` (gauche de `C`)
-* `B` à droite de `A` (gauche de `C`)
-* `v1` à droite de `A` (gauche de `B`)
-![Après équilibrage](figs/cas2a_droite.png)
+```C
+arbre symétrie(arbre)
+    si !est_feuille(arbre)
+        échanger(arbre.enfant[0], arbre.enfant[1])
+        échanger(arbre.enfant[2], arbre.enfant[3])
+        pour i de 0 à 3
+            symétrie(arbre.enfant[i])
+    retourne arbre
+```
-::::
+# La symétrie d'axe horizontal
-:::
+* Trivial de faire l'axe horizontal (exercice à la maison)
+# Rotation d'un quart de cercle
+## Comment faire sur un arbre?
-# Rappel: Rééquilibrage
+* Faire un dessin de l'arbre avant/après (5min, matrix)
+    ```
+       SG=0  |  SD=1        SG=0  |  SD=1   
+     21 | 12 | 4 |  4      4 |  4 | 31 | 27
+      9 |  7 | 4 |  4      4 |  4 |  0 |  3
+    -----------------  => ----------------- 
+      1 |  1 | 0 | 31     12 |  7 |  1 |  1
+      1 |  1 | 3 | 27     21 |  9 |  1 |  1
+       IG=2  |  ID=3        IG=2  |  ID=3
-## Rotation simple
+    ```
-![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
+* Écrire le pseudo-code (3min, matrix)
-# Rappel: La rotation gauche-droite
+. . .
-## Le cas 2a/b
+```C
+rien rotation_gauche(arbre) 
+    si !est_feuille(arbre)
+        échange_cyclique_gauche(arbre.enfant)
+        pour i de 0 à 3
+            rotation_gauche(arbre.enfant[i])
+```
-![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
+# Rotation d'un quart de cercle
-# Un petit exercice
+\footnotesize
-* Insérer les nœuds suivants dans un arbre AVL
+## Comment faire sur un arbre?
 ```
-25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40 
+   SG=0  |  SD=1        SG=0  |  SD=1   
-    | 50 | 55 | 30 | 15
+ 21 | 12 | 4 |  4      4 |  4 | 31 | 27
+  9 |  7 | 4 |  4      4 |  4 |  0 |  3
+-----------------  => ----------------- 
+  1 |  1 | 0 | 31     12 |  7 |  1 |  1
+  1 |  1 | 3 | 27     21 |  9 |  1 |  1
+   IG=2  |  ID=3        IG=2  |  ID=3
 ```
+* Écrire le vrai code (5min, matrix)
+. . .
+```C
+void rotate(node *qt) {
+    if (!is_leaf(qt)) {
+        node *tmp = qt->child[2];
+        qt->child[2] = qt->child[0];
+        qt->child[0] = qt->child[1];
+        qt->child[1] = qt->child[3];
+        qt->child[3] = tmp;
+        for (int i=0; i<CHILDREN; i++) { 
+            rotate(qt->child[i]);
+        }
+    }
+}
 ```
+# Compression sans perte (1/5)
+## Idée générale
+* Regrouper les pixels par valeur
+```
+   SG=0  |  SD=1        SG=0   |  SD=1   
+ 21 | 12 | 4 |  4      21 | 12 |   4
+  9 |  7 | 4 |  4       9 |  7 |  
+-----------------  => ----------------- 
+  1 |  1 | 0 | 31         1    |  0 | 31
+  1 |  1 | 3 | 27              |  3 | 27
+   IG=2  |  ID=3        IG=2   |  ID=3
+```
+* Comment faire?
+# Compression sans perte (2/5)
+## Que devient l'arbre suivant?
+![](figs/quad_img_simple.svg)
+. . . 
+## Arbre compressé
-```
+![](figs/quad_img_simple_comp.svg)
+# Compression sans perte (3/5)
-# Suppression dans un arbre AVL
+* Si un nœud a tous ses enfants égaux:
+    * Stocker cette valeur dans ce nœud,
+    * Supprimer ses enfants.
+* Jusqu'à remonter à la racine.
+## Écrire le pseudo-code (5min, matrix)
-::: columns
+. . .
-:::: column
+```C
+rien compression_sans_perte(arbre)
-## Algorithme par problème: supprimer 10
+    si !est_feuille(arbre)
+        pour i de 0 à 3
-```{.mermaid format=pdf width=400 loc=figs/}
+            compression_sans_perte(arbre.enfant[i])
-graph TD;
+        si derniere_branche(arbre)
-    id0((8))-->id1((4));
+            valeur, toutes_égales = valeur_enfants(arbre)
-    id0-->id2((10));
+            si toutes_egales
-    id1-->id3((2));
+                arbre.info = valeur
-    id1-->id4((6));
+                detruire_enfants(arbre)
-    id3-->id5((1));
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((9))
-    id2-->id10((14))
-    id10-->id11((12))
-    id10-->id12((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
 ```
-::::
+# Compression sans perte (4/5)
+\footnotesize
-:::: column
+## Écrire le code C (5min, matrix)
 . . .
-## Algorithme par problème: supprimer 10
+```C
+void lossless_compression(node *qt) {
-```{.mermaid format=pdf width=400 loc=figs/}
+    if (!is_leaf(qt)) {
-graph TD;
+        for (int i=0; i<CHILDREN; i++) {
-    id0((8))-->id1((4));
+            lossless_compression(qt->child[i]);
-    id0-->id2((12));
+        }
-    id1-->id3((2));
+        if (is_last_branch(qt)) {
-    id1-->id4((6));
+            int val = -1;
-    id3-->id5((1));
+            if (last_value(qt, &val)) {
-    id3-->id6((  ))
+                qt->info = val;
-    id4-->id7((  ))
+                for (int i=0; i<CHILDREN; ++i) {  
-    id4-->id8((7))
+                    free(qt->child[i]);
-    id2-->id9((9))
+                    qt->child[i] = NULL;
-    id2-->id10((14))
+                }
-    id10-->id11((  ))
+            }
-    id10-->id12((16))
+        }
-    style id6 fill:#fff,stroke:#fff
+    }
-    style id7 fill:#fff,stroke:#fff
+}
-    style id11 fill:#fff,stroke:#fff
 ```
-::::
+# Compression sans perte (5/5)
-:::
+\footnotesize
-# Suppression dans un arbre AVL
+```C
+bool is_last_branch(node *qt) {
+    for (int i = 0; i < CHILDREN; ++i) {
+        if (!is_leaf(qt)) {
+            return false;
+        }
+    }
+    return true;
+}
+bool last_value(node *qt, int *val) {
+    int info = qt->child[0];
+    for (int i = 1; i < CHILDREN; ++i) {
+        if (info != qt->child[i]) {
+            return false;
+        }
+    }
+    *val = info;
+    return true;
+}
+```
-::: columns
+# Compression avec perte (1/5)
+## Idée générale
-:::: column
+* Regrouper les pixels par valeur sous certaines conditions
-## Algorithme par problème: supprimer 8
+```
+   SG=0  |  SD=1        SG=0   |  SD=1   
-```{.mermaid format=pdf width=400 loc=figs/}
+ 21 | 12 | 4 |  3      21 | 12 |    4
-graph TD;
+  9 |  7 | 4 |  4       9 |  7 |  
-    id0((8))-->id1((4));
+-----------------  => ------------------
-    id0-->id2((12));
+  1 |  1 | 0 | 31         1    |  0 | 31
-    id1-->id3((2));
+  2 |  1 | 3 | 27              |  3 | 27
-    id1-->id4((6));
+   IG=2  |  ID=3        IG=2   |  ID=3
-    id3-->id5((1));
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((9))
-    id2-->id10((14))
-    id10-->id11((  ))
-    id10-->id12((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-    style id11 fill:#fff,stroke:#fff
 ```
-::::
+* On enlève si l'écart à la moyenne est "petit"?
-:::: column
+# Compression avec perte (2/5)
+## Que devient l'arbre suivant si l'écart est petit?
+![](figs/quad_img_simple_variation.svg)
 . . . 
-## Algorithme par problème: rotation de 12
+## Arbre compressé
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((9))-->id1((4));
-    id0-->id2((12));
-    id1-->id3((2));
-    id1-->id4((6));
-    id3-->id5((1));
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((  ))
-    id2-->id10((14))
-    id10-->id11((  ))
-    id10-->id12((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-    style id9 fill:#fff,stroke:#fff
-    style id11 fill:#fff,stroke:#fff
-```
-::::
+![](figs/quad_img_simple_comp_loss.svg)
-:::
+# Compression avec perte (3/5)
-# Suppression dans un arbre AVL
+## Comment mesurer l'écart à la moyenne?
-::: columns
+. . .
-:::: column
+* Avec l'écart-type
-## Algorithme par problème: rotation de 12
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((9))-->id1((4));
-    id0-->id2((14));
-    id1-->id3((2));
-    id1-->id4((6));
-    id3-->id5((1));
-    id3-->id6((  ))
-    id4-->id7((  ))
-    id4-->id8((7))
-    id2-->id9((12))
-    id2-->id10((16))
-    style id6 fill:#fff,stroke:#fff
-    style id7 fill:#fff,stroke:#fff
-```
-::::
+\begin{equation*}
+\mu = \frac{1}{4}\sum_{i=0}^{3} p[i],\quad \sigma = \sqrt{\frac{1}{4}\sum_{i=0}^3 (\mu-p[i])
+^2} = \sqrt{\frac{1}{4}\left(\sum_{i=0}^3p[i]^2\right)-\mu^2}
+\end{equation*}
-:::: column
+## Que devient l'algorithme?
 . . .
-1. On supprime comme d'habitude.
+* Si $\sigma<\theta$, où $\theta$ est la **tolérance**:
-2. On rééquilibre si besoin à l'endroit de la suppression.
+    * Remplacer la valeur du pixel par la moyenne des enfants.
+    * Remonter les valeurs dans l'arbre.
-* Facile non?
+## Quelle influence de la valeur de $\theta$ sur la compression?
 . . .
-* Plus dur....
+* Plus $\theta$ est grand, plus l'image sera compressée.
-::::
+# Compression avec perte (4/5)
-:::
+## Que devient l'arbre avec $\theta=0.5$?
-# Suppression dans un arbre AVL 2.0
+![L'arbre original.](figs/quad_img_simple_variation.svg)
-::: columns
+. . .
-:::: column
+![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)
-## Algorithme par problème: suppression de 30
-```{.mermaid format=pdf width=400 loc=figs/}
-graph TD;
-    id0((50))-->id1((30));
-    id0-->id2((100));
-    id1-->id3((10));
-    id1-->id4((40));
-    id3-->id5((  ));
-    id3-->id6((20))
-    id2-->id7((80))
-    id2-->id8((200))
-    id7-->id9((70))
-    id7-->id10((90))
-    id9-->id11((60))
-    id9-->id12((  ))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id5 fill:#fff,stroke:#fff
-    style id12 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
-```
-::::
+# Compression avec perte (5/5)
-:::: column
+## Modifications sur la structure de données?
 . . .
-## Algorithme par problème: rotation GD autour de 40
+* On stocke la moyenne, et la moyenne des carrés.
-```{.mermaid format=pdf width=400 loc=figs/}
+```C
-graph TD;
+struct noeud
-    id0((50))-->id1((40));
+    flottant moyenne, moyenne_carre
-    id0-->id2((100));
+    node enfants[4]
-    id1-->id3((10));
-    id1-->id4((  ));
-    id3-->id5((  ));
-    id3-->id6((20))
-    id2-->id7((80))
-    id2-->id8((200))
-    id7-->id9((70))
-    id7-->id10((90))
-    id9-->id11((60))
-    id9-->id12((  ))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id4 fill:#fff,stroke:#fff
-    style id5 fill:#fff,stroke:#fff
-    style id12 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
 ```
-::::
+* Comment on calcule `moyenne` et `moyenne_carre` sur chaque nœud (pseudo-code)?
-:::
+# Calcul de la moyenne
-# Suppression dans un arbre AVL 2.0
+## Pseudo-code (5min, matrix)
-::: columns
+. . .
-:::: column
+```C
+rien moyenne(arbre) {
-## Argl! 50 est déséquilibré!
+    si !est_feuille(arbre)
+        pour enfant dans arbre.enfants
-```{.mermaid format=pdf width=400 loc=figs/}
+            moyenne(enfant)
-graph TD;
+        pour enfant dans arbre.enfants
-    id0((50))-->id1((20));
+            arbre.moyenne += enfant.moyenne
-    id0-->id2((100));
+            arbre.moyenne_carre += enfant.moyenne_carre
-    id1-->id3((10));
+        arbre.moyenne /= 4
-    id1-->id4((40));
+        arbre.moyenne_carre /= 4
-    id2-->id7((80))
-    id2-->id8((200))
-    id7-->id9((70))
-    id7-->id10((90))
-    id9-->id11((60))
-    id9-->id12((  ))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id12 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
 ```
-::::
+# La compression avec pertes
-:::: column
+\footnotesize
+## Pseudo-code (5min, matrix)
 . . .
-## Algorithme par problème: rotation DG autour de 50
+```C
+rien compression_avec_pertes(arbre, theta)
-```{.mermaid format=pdf width=400 loc=figs/}
+    si !est_feuille(arbre)
-graph TD;
+        pour i de 0 à 3
-    id0((80))-->id1((50));
+            compression_avec_pertes(arbre.enfant[i])
-    id0-->id2((100));
+        si derniere_branche(arbre)
-    id1-->id3((20));
+            si racine(arbre.moyenne_carre - arbre.moyenne^2) < theta
-    id1-->id4((70));
+                detruire_enfants(arbre)
-    id3-->id5((10));
-    id3-->id6((40));
-    id4-->id9((60))
-    id4-->id10((  ))
-    id2-->id7((90))
-    id2-->id8((200))
-    id8-->id13((  ))
-    id8-->id14((300))
-    style id10 fill:#fff,stroke:#fff
-    style id13 fill:#fff,stroke:#fff
 ```
-::::
+## Le code en entier
-:::
+```C
+arbre = matrice_à_arbre(matrice)
+moyenne(arbre)
+compression_avec_pertes(arbre)
+```
-# Résumé de la suppression
+# La dynamique des corps célestes
-1. On supprime comme pour un arbre binaire de recherche.
+## Slides très fortement inspirés du cours de J. Latt, Unige
-2. Si un nœud est déséquilibré, on le rééquilibre.
-    * Cette opération peut déséquilibrer un autre nœud.
-3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer.
+## Simulation du problème à $N$-corps
-# Les arbres quaternaires
+* Prédiction du mouvement d'un grand nombre de corps célestes.
+* Modélisation:
+    * On se limite aux étoiles;
+    * Chaque étoile est caractérisée par un point (coordonnées) et une masse;
+    * On simule en deux dimensions.
+    * Interactions uniquement par les lois de la gravitation Newtonienne (oui-oui c'est de la **physique**!).
-\Huge Les arbres quaternaires
+# Les équations du mouvement
-# Les arbres quaternaires
+## Mouvement de la $i$-ème étoile
-## Définition
+* Algorithme de Verlet ($t_{n+1}=t_n+\delta t$)
-Arbre dont chaque nœud a 4 enfants ou aucun. 
+    $$
+   \vec x_i(t_{n+1})= 2\vec x_i(t_n)-\vec x_i(t_{n-1})+\vec a_i(t_n)\delta t^2.
+   $$
-![Un exemple d'arbre quaternaire.](figs/quad_ex.svg)
+## Force de gravitation
-# Les arbres quaternaires
+* $\vec a_i(t_n)=\vec F_i/m_i$.
+* Sur l'étoile $i$, la force résultante est donnée par
-## Cas d'utilisation
+    $$
+    \vec F_i=\sum_{j=1,j\neq i}^N \vec F_{ij}.
+    $$
+    avec
+    $$
+    \vec F_{ij}=\frac{G m_i m_j(\vec x_j-\vec x_i)}{||\vec x_j-\vec x_i||^3}.
+    $$
-Typiquement utilisés pour représenter des données bidimensionnelles.
+# Algorithme du problème à $n$-corps
-Son équivalent tri-dimensionnel est l'octree (chaque nœud a 8 enfants ou aucun).
+## Pseudo-code: structure de données
-## Cas d'utilisation: images
+```C
+struct étoile
+    flottant m
+    vec x, x_precedent, f
+```
-* Stockage: compression.
+## Pseudo-code: itération temporelle
-* Transformations: symétries, rotations, etc.
-## Cas d'utilisation: simulation
+```C
+rien iteration_temporelle(étoiles, dt)
+    pour étoile_une dans étoiles
+        étoile_une.f = 0
+        pour étoile_deux dans étoiles
+            si (étoile_un != étoile_deux)
+                étoile_une.f += 
+                    force(étoile_une, étoile_deux)
+    pour étoile dans étoiles
+        étoile.x, étoile.x_precedent = 
+            verlet(étoile.x, étoile.x_precedent, 
+                   étoile.f / étoile.m, dt)
+```
-* Indexation spatiale.
+# Algorithme du problème à $n$-corps
-* Détection de collisions.
-* Simulation de galaxies, Barnes-Hut.
-# Exemple de compression
+## Complexité
-::: columns
+* Complexité de chacune des parties?
-:::: {.column width=30%}
+. . .
-## Comment représenter l'image
+* $\mathcal{O}(N^2)$, $\mathcal{O}(N)$.
-![Image noir/blanc.](figs/board_blacked_parts.svg)
+## En temps CPU pour **une itération**
-::::
+\footnotesize
-:::: {.column width=70%}
+* Si le temps pour $N=1$ est environ $1\mu s$, on a:
-## Sous la forme d'un arbre quaternaire?
+--------+-------+-------+-----------+
+|     N  |  N^2  | t [s] | t [réel]  |
+--------+-------+-------+-----------+
+|    10  |  10^2 | 1e-4  |           |
+--------+-------+-------+-----------+
+|  10^4  |  10^8 | 1e+2  | ~1min     |
+--------+-------+-------+-----------+
+|  10^6  | 10^12 | 1e+6  | ~11j      |
+--------+-------+-------+-----------+
+|  10^9  | 10^18 | 1e+12 | ~30K ans  |
+--------+-------+-------+-----------+
+|  10^11 | 10^22 | 1e+16 | ~300M ans |
+--------+-------+-------+-----------+
-. . .
+* Typiquement, il y a des milliers-millions d'itérations.
+* Il y a $10^{11}$ étoiles dans la galaxie.
+* Houston we have a problem.
-![L'arbre quaternaire correspondant.](figs/quad_img.svg)
+# Question
-**Économie?**
+## Comment faire mieux? Des idées?
 . . .
-Image 64 pixels, arbre 25 nœuds.
+* Si un groupe d'étoiles est suffisamment loin, on le modélise comme un corps unique situé en son centre de masse.
+* Exemple: Si on simule plusieurs galaxies, on considère chaque galaxie comme un corps unique!
+* Un arbre quaternaire est une structure parfaite pour regrouper les étoiles.
+# Le cas à 10 corps
+::: columns
+:::: {.column width=50%}
+## Illustration: le cas à 10 corps
+![](figs/nbody_bare.png){width=60%}
+::::
+:::: {.column width=50%}
+## Problématique
+* On veut calculer la force sur $1$.
 ::::
 :::
+. . .
-# Structure de données
 ::: columns
 :::: {.column width=50%}
-## Pseudo-code?
+## Illustration: le cas à 10 corps
-. . .
+![](figs/nbody_n2.png){width=60%}
-```python
-struct node
-    info
-    node sup_gauche, sup_droit,
-        inf_gauche, inf_droit
-```
-![Un nœud d'arbre quaternaire.](figs/quad_struct.svg)
+::::
+:::: {.column width=50%}
+## Résultat
+* Calcul et somme des forces venant des $9$ autre corps.
 ::::
+:::
+# Le cas à 10 corps
+::: columns
 :::: {.column width=50%}
-## En C?
+## Réduction d'un groupe à un seul corps
-. . .
+![](figs/nbody_group.png){width=100%}
-```C
+::::
-struct _node {
-    int info;
-    struct _node *sup_left;
-    struct _node *sup_right;
-    struct _node *inf_left;
-    struct _node *inf_right;
-};
-```
-* Pourquoi le `*` est important?
+:::: {.column width=50%}
-. . .
+## Idée
-* Type récursif => taille inconnue à la compilation.
+* On accélère le calcul en traitant un groupe comme un seul corps.
+* Fonctionne uniquement si le groupe est assez loin.
+* Autrement l'approximation est trop grossière.
 ::::
 :::
-# Une fonctionnalité simple
+# Solution: l'arbre quaternaire
-\footnotesize
+## Corps célestes - arbre
-## La fonction `est_feuille(noeud)`
+![](figs/nbody_qt_withtree.png)
-* Problème avec cette implémentation?
+* On omet les nœuds vides pour alléger la représentation.
+* La numérotation est:
+    * 0: ID
+    * 1: SD
+    * 2: IG
+    * 3: SG
-```python
+# Exemple d'insertion
-bool est_feuille(noeud) 
-    retourne
-        est_vide(sup_gauche(noeud)) &&
-        est_vide(sup_droit(noeud)) &&
-        est_vide(inf_gauche(noeud)) &&
-        est_vide(inf_droit(noeud))
-```
-. . .
+::: columns
-* Inutile d'avoir 4 conditions (soit 4 enfants soit aucun!)
+:::: {.column width=50%}
-* Facile d'en oublier un!
-* Comment changer la structure pour que ça soit moins terrible?
-. . .
+## Insertion corps 1
-```python
+![](figs/corps1.png){width=100%}
-struct node
-    info
-    node enfant[4]
-```
-# Structure de données
+::::
-## En C?
+:::: {.column width=50%}
-. . .
+## Arbre, niveau 1
-```C 
+![](figs/arbre1.png){width=100%}
-typedef struct _node {
-    int info;
-    struct _node *child[4];
-} node;
-```
-## Fonction `is_leaf(node *tree)`?
+* Quadrant ID.
+* La feuille est vide, on insère.
-. . .
+::::
-```C 
+:::
-bool is_leaf(node *tree) {
-    return (NULL == tree->child[0]); // only first matters
-}
-```
-# Problème à résoudre
+# Exemple d'insertion
-* Construire un arbre quaternaire à partir d'une image:
+::: columns
-    * Créer l'arbre (allouer la mémoire pour tous les nœuds),
-    * Le remplir avec les valeurs des pixels.
-* Compression de l'image:
-    * Si les pixels sont les mêmes dans le quadrant on supprime le sous-arbre (sans perte)
-    * Si les pixels dévient pas trop on supprime le quadrant (avec perte)
-# Création de l'arbre
+:::: {.column width=50%}
-## Comment créer un arbre de profondeur `prof` (3min)?
+## Insertion corps 2
-. . .
+![](figs/corps2.png){width=100%}
-```python
+::::
-arbre creer_arbre(prof)
-    n = nouveau_noeud() # alloue la mémoire
-    si prof > 0
-        pour i = 0 à 3
-            n.enfant[i] = creer_arbre(prof-1)
-    retourne n
-```
-## En `C` (3 min, matrix)?
+:::: {.column width=50%}
-. . .
+## Arbre, niveau 1
-```C
+![](figs/arbre2.png){width=100%}
-node *qt_create(int depth) {
-    node *n = calloc(1, sizeof(node));
-    if (depth > 0) {
-        for (int i = 0; i < 4; ++i) {
-            n->child[i] = qt_create(depth-1);
-        }
-    }
-    return n;
-}
-```
-# Le nombre de nœuds?
+* Quadrant SD.
+* La feuille est vide, on insère.
-## Comment implémenter la fonction (pseudo-code, 5min, matrix)?
+::::
-. . .
+:::
-```C
+# Exemple d'insertion
-entier nombre_nœuds(arbre)
-    si est_feuille(arbre)
-        retourne 1
-    sinon
-        somme = 1
-        pour i de 0 à 3
-            somme += nombre_nœuds(arbre.enfant[i])
-        retourne somme
-```
-# Le nombre de nœuds?
+::: columns
-## Comment implémenter la fonction en C (3min, matrix)?
+:::: {.column width=50%}
-. . .
+## Insertion corps 3 (1/N)
-```C
+![](figs/corps3_1.png){width=100%}
-int size(node *qt) {
-    if (is_leaf(qt)) {
-        return 1;
-    } else {
-        int sum = 1;
-        for (int i = 0; i < 4; ++i) {
-            sum += size(qt->child[i]);
-        }
-        return sum;
-    }
-}
-```
-# La profondeur en C?
+::::
-## Implémentation (5min, matrix)
+:::: {.column width=50%}
-. . .
+## Arbre, niveau 1
-\footnotesize
+![](figs/arbre3_1.png){width=100%}
-```C
+* Quadrant SD.
-int max(int x, int y) {
+* La feuille est prise par 2.
-   return  (x >= y ? x : y);
-}
-int max_depth(int depths[4]) {
-    int m = depths[0];
-    for (int i = 1; i < 4; ++i) {
-        m = max(m, depths[i]);
-    }
-    return m;
-}
-int depth(node *qt) {
-    int depths[] = {0, 0, 0, 0};
-    if (is_leaf(qt)) {
-        return 0;
-    } else {
-        for (int i = 0; i < 4; ++i) {
-            depths[i] = depth(qt->child[i]);
-        }
-        return 1 + max_depth(depths);
-    }
-}
-```
-# Fonctions utiles (1/4)
+::::
-## Comment remplir un arbre depuis une matrice?
+:::
-```
+# Exemple d'insertion
-   SG=0  |  SD=1
- 21 | 12 | 4 |  4
-  9 |  7 | 4 |  4
-----------------
-  1 |  1 | 0 | 31
-  1 |  1 | 3 | 27
-   IG=2  |  ID=3
-```
-## Quel arbre cela représente?
+::: columns
-. . .
+:::: {.column width=50%}
-![L'arbre correspondant](figs/quad_img_simple.svg)
+## Insertion corps 3 (2/N)
-# Fonctions utiles (2/4)
+![](figs/corps3_2.png){width=100%}
-* On veut transformer une ligne/colonne en feuille.
+::::
-* Comment?
-::: columns
+:::: {.column width=50%}
-:::: {.column width=40%}
+## Arbre, niveau 2
-## Soit `ligne=2`, `colonne=3`
+![](figs/arbre3_2.png){width=100%}
-```
+* On crée un nouveau nœud.
-   SG=0  |  SD=1
+* Deux corps dans le nœud ID.
- 21 | 12 | 4 |  4
+* On crée un nouveau nœud.
-  9 |  7 | 4 |  4
-----------------
-  1 |  1 | 0 | 31
-  1 |  1 | 3 | 27
-   IG=2  |  ID=3
-```
 ::::
-:::: {.column width=70%}
+:::
+# Exemple d'insertion
-## Trouver un algorithme
+::: columns
-![Déterminer un algorithme.](figs/quad_img_simple.svg)
+:::: {.column width=50%}
-* Quelle feuille pour 31 (`li=2`, `co=3`)?
+## Insertion corps 3 (3/N)
-* Plus important: quel chemin?
-. . .
+![](figs/corps3_3.png){width=100%}
-* `co -> G/D`, `li -> S/I`,
+::::
-* `2 * (li / 2) + co / 2 -> 2 * 1 + 1 = 3`
-* `2 * ((li % 2) / 1) + (co % 2) / 1 -> 2 * 0 + 1 = 1`
+:::: {.column width=50%}
-* Comment généraliser?
+## Arbre, niveau 3
+![](figs/arbre3_3.png){width=100%}
+* 2 va dans ID.
+* 3 va dans SG.
+* C'est des feuilles vides, tout va bien.
 ::::
 :::
-# Fonctions utiles (3/4)
+# Exemple d'insertion
 ::: columns
-:::: {.column width=40%}
+:::: {.column width=50%}
-## Soit `ligne=2`, `colonne=3`
+## Que fait-on avec les nœuds intérieurs?
-```
+* On les utilise pour:
-   SG=0  |  SD=1
+    * stocker la masse totale;
- 21 | 12 | 4 |  4
+    * stocker le centre de masse.
-  9 |  7 | 4 |  4
-----------------
+\begin{align}
-  1 |  1 | 0 | 31
+m&=m_2+m_3,\\
-  1 |  1 | 3 | 27
+\vec x &= \frac{m_2\vec x_2+m_3\vec x_3}{m}.
-   IG=2  |  ID=3
+\end{align}
-```
+## Chaque feuille contient **une étoile**
 ::::
-:::: {.column width=70%}
+:::: {.column width=50%}
-## Trouver un algorithme (prendre plusieurs exemples, 15min, matrix)
+## Arbre
-![Déterminer un algorithme.](figs/quad_img_simple.svg)
+![](figs/arbre3_3.png){width=100%}
-* Comment généraliser?
+::::
-. . .
+:::
+# Résumé
+* Insertion du corps `c` dans le nœud `n` en partant de la racine.
+* Si le nœud `n`
+    * ne contient pas de corps, on y dépose `c`;
+    * est interne, on met à jour masse et centre de masse, `c` est inséré récursivement dans le bon quadrant;
+    * est externe, on subdivise `n`, on met à jour la masse et centre de masse, on insère récursivement les deux nœuds dans les quadrants appropriés.
+## Remarque
+* Il faut stocker les coordonnées des quadrants.
+* Un nœud a un comportement différent s'il est interne ou externe.
+# Algorithme d'insertion
+## Structure de données
 ```C
-noeud position(li, co, arbre)
+struct node
-    d = profondeur(arbre);
+    etoile e // externe: pour stocker 
-    tant_que (d >= 1)
+    etoile sup_etoile // interne: pour stocker m, x
-        index = 2 * ((li % 2^d) / 2^(d-1)) +
+    quadrant q  // coordonnées du quadrant
-            (col % 2^d) / 2^(d-1)
+    node enfants[4]
-        arbre = arbre.enfant[index]
-        d -= 1
-    retourne arbre
 ```
+## Remarque: 
-::::
+* On fait une simplification "moche": `sup_etoile` pourrait juste avoir une masse et une position.
-:::
+# Algorithme d'insertion
-# Fonctions utiles (4/4)
 \footnotesize
-## Pseudo-code
+## Algorithme d'insertion, pseudo-code (15min, matrix)
+. . .
 ```C
-noeud position(li, co, arbre)
+rien insertion_etoile(arbre, e)  
-    d = profondeur(arbre);
+    si (!est_vide(arbre) && dans_le_quadrant(arbre.q, e.x)) {
-    tant_que (d >= 1)
+        si (est_feuille(arbre))
-        index = 2 * ((li % 2^d) / 2^(d-1)) +
+            si (!contient_etoile(arbre))
-            (col % 2^d) / 2^(d-1)
+                arbre.e = e
-        arbre = arbre.enfant[index]
+            sinon
-        d -= 1
+                // on crée enfants et arbre.sup_etoile est initialisée
-    retourne arbre
+                subdivision_arbre(arbre, e) 
+                pour enfant dans arbre.enfants
+                    insertion_etoile(enfant, arbre.e)
+                pour enfant dans arbre.enfants
+                    insertion_etoile(enfant, e)
+                destruction(arbre.e)
+        sinon
+            maj_masse_cdm(arbre.sup_etoile, e)
+            pour enfant dans arbre.enfants
+                insertion_etoile(enfant, e)
 ```
-## Écrire le code `C` correspondant (5min, matrix)
+# Utilisation de l'arbre
-```C
+* L'arbre est rempli: comment on calcule la force sur le corps 1?
+* Parcours de l'arbre: 
+    * Si la distance entre 1 et le centre de masse est suffisante, on utilise la masse totale et centre de masse pour calculer la force.
+    * Sinon on continue le parcours.
+# Calcul de la force
+## Calcul de la force sur `1`
+![](figs/force_1.png)
+* Le cadrant ID ne contient que `1`, rien à faire.
+# Calcul de la force
+## Calcul de la force sur `1`
+![](figs/force_2.png)
+* Le cadrant SG contient `5` corps.
+# Calcul de la force
+## Calcul de la force sur `1`
-```
+![](figs/force_3.png)
-# Remplir l'arbre
+* La distance entre `1` et le centre de masse de SG est `d`.
-## A partir d'une matrice (pseudo-code, 5min, matrix)?
+# Calcul de la force
-. . .
+## Calcul de la force sur `1`
-```C
+![](figs/force_4.png)
-arbre matrice_à_arbre(matrice)
-    arbre = creer_arbre(profondeur)
-    pour li de 0 à nb_lignes(matrice)
-        pour co de 0 à nb_colonnes(matrice)
-            noeud = position(li, co, arbre)
-            noeud.info = matrice[co][li]
-    retourne arbre
-```
-. . .
+* La distance entre `1` et le centre de masse de SG est `d`.
+* Est-ce que `d` est assez grand?
+* On va comparer avec la distance `d` avec la taille du quadrant `s`.
-## A partir d'une matrice (C, 5min, matrix)?
+# Critère $\theta$
-. . .
+* On compare $d=||\vec x_1-\vec x_{cm}||$ avec $s$ la taille du quadrant.
+* Le domaine est assez éloigné si
-\footnotesize
+    $$
+    \frac{s}{d}<\theta,
+    $$
+* $\theta$ est la valeur de seuil.
+* Une valeur typique est $\theta=0.5$, donc la condition devient
-```C
+    $$
-node *matrix_to_qt(int nb_li, int nb_co, int matrix[nb_li][nb_co], int depth)
+    d>2s.
-{
+    $$
-    node *qt = qt_create(depth);
-    for (int li = 0; li < nd_li; ++li) {
-        for (int co = 0; co < nd_co; ++co) {
-            node *current = position(li, co, qt);
-            current->info = matrix[li][co];
-        }
-    }
-    return qt;
-}
-```
+# Calcul de la force
-# Remplir la matrice
+## Calcul de la force sur `1`
-## A partir de l'arbre (pseudo-code, 3min, matrix)?
+![](figs/force_4.png)
-. . .
+* Ici $d<2s$, domaine rejeté.
+* On descend dans l'arbre.
-```C
+# Calcul de la force
-matrice arbre_à_matrice(arbre)
-    matrice = creer_matrice(nb_lignes(arbre), nb_colonnes(arbre))
-    pour li de 0 à nb_lignes(matrice)
-        pour co de 0 à nb_colonnes(matrice)
-            noeud = position(li, co, arbre)
-            matrice[co][li] = noeud.info
-    retourne matrice
-```
-. . .
+## Calcul de la force sur `1`
+![](figs/force_5.png)
+* `s` est plus petit, mais....
+* Cela ne suffit pas $d<2s$, domaine rejeté.
+# Calcul de la force
-## A partir de l'arbre (C, 3min, matrix)?
+## Calcul de la force sur `1`
+![](figs/force_6.png)
+* Les nœuds sont des feuilles, on calcule la force.
+* On ajoute la force qu'ils exercent sur `1`.
+# Algorithme pour le calcul de la force
+Pour calculer la force sur un corps `c`, on parcourt l'arbre en commençant par la racine:
+* Si le nœud `n` est une feuille et n'est pas `c`, on ajoute la force dûe à `n` sur `c`;
+* Sinon, si $s/d<\theta$, on traite `n` comme une feuille et on ajoute la force dûe à `n` sur `c`;
+* Sinon on continue sur les enfants récursivement.
+## Continuons notre exemple précédent!
+# Calcul de la force
+## Calcul de la force sur `1`
+![](figs/force_7.png)
+* Il y a deux corps dans le quadrant vert.
+* Quel est le critère pour remplacer les étoiles par leur centre de masse?
 . . .
+* Et oui! $d>2s$, donc on peut remplacer les étoiles par leur centre de masse!
+# Algorithme du calcul de force
+## Écrire le pseudo-code-code du calcul de la force
 \footnotesize
 ```C
-void qt_to_matrix(node *qt, int nb_li, int nb_co, int matrix[nb_li][nb_co])
+rien maj_force_sur_etoile(arbre, e, theta)
-    for (int li = 0; li < nd_li; ++li) {
+    si est_vide(arbre)
-        for (int co = 0; co < nd_co; ++co) {
+        retourne
-            node *current = position(li, co, qt);
-            matrix[li][co] = current->info;
-        }
-    }
-```
+    si est_feuille(arbre) && contient_etoile(arbre) 
+                          && dans_le_quadrant(arbre.q, e.x)
+        maj_force(e, arbre.e)
+    sinon si noeud_assez_loin(arbre, e, theta)
+        maj_force(e, arbre.sup_etoile)
+    sinon
+        pour enfant dans enfants
+            maj_force_sur_etoile(enfant, e, theta)
+```
--- a/slides/cours_21.md
+++ b/slides/cours_21.md
 ---
-title: "Arbres quaternaires"
+title: "Les B-arbres"
-date: "2024-04-25"
+date: "2025-04-11"
 ---
-# Les arbres quaternaires
+# Les B-arbres
-\Huge Les arbres quaternaires
+\Huge
+Les B-arbres
-# Les arbres quaternaires
-## Définition
+# Les B-arbres
-Arbre dont chaque nœud a 4 enfants ou aucun. 
+## Problématique
-![Un exemple d'arbre quaternaire.](figs/quad_ex.svg)
-# Les arbres quaternaires
-## Cas d'utilisation
-Typiquement utilisés pour représenter des données bidimensionnelles.
-Son équivalent tri-dimensionnel est l'octree (chaque nœud a 8 enfants ou aucun).
-## Cas d'utilisation: images
-* Stockage: compression.
-* Transformations: symétries, rotations, etc.
-## Cas d'utilisation: simulation
-* Indexation spatiale.
-* Détection de collisions.
-* Simulation de galaxies, Barnes-Hut.
-# Exemple de compression
+* Grands jeux de données (en 1970).
+* Stockage dans un arbre, mais l'arbre ne tient pas en mémoire.
+* Regrouper les sous-arbres en **pages** qui tiennent en mémoire.
-::: columns
+## Exemple
-:::: {.column width=30%}
+* 100 nœuds par page et l'arbre comporte $10^6$ nœuds:
+    * Recherche B-arbre: $\log_{100}(10^6)=3$;
+    * Recherche ABR: $\log_2(10^6)=20$.
+* Si on doit lire depuis le disque: $10\mathrm{ms}$ par recherche+lecture:
+    * $30\mathrm{ms}$ (lecture beaucoup plus rapide que recherche) vs $200\mathrm{ms}=0.2\mathrm{s}$.
-## Comment représenter l'image
+## Remarques
-![Image noir/blanc.](figs/board_blacked_parts.svg)
+* On ne sait pas ce que veut dire `B`: Bayer, Boeing, Balanced?
+* Variante plus récente B+-arbres.
-::::
+# Les B-arbres
-:::: {.column width=70%}
+## Illustration, arbre divisé en pages de 3 nœuds
-## Sous la forme d'un arbre quaternaire?
+![Arbre divisé en pages de 3 nœuds](figs/barbres_page3.png)
 . . .
-![L'arbre quaternaire correspondant.](figs/quad_img.svg)
+## Utilisation
-**Économie?**
+* Bases de données (souvent très grandes donc sur le disque);
+* Systèmes de fichiers.
-. . .
+# Les B-arbres
-Image 64 pixels, arbre 25 nœuds.
+## Avantages
-::::
+* Arbres moins profonds;
+* Diminution des opérations de rééquilibrage;
+* Complexité toujours en $\log(N)$;
-:::
+. . .
+## Définition: B-arbre d'ordre $n$
-# Structure de données
+* Chaque page d'un arbre contient au plus $2\cdot n$ *clés*;
+* Chaque page (excepté la racine) contient au moins $n$ clés;
+* Chaque page qui contient $m$ clés contient soit:
+    * $0$ descendants;
+    * $m+1$ descendants.
+* Toutes les pages terminales apparaissent au même niveau.
-::: columns
+# Les B-arbres
-:::: {.column width=50%}
+## Est-ce un B-arbre?
-## Pseudo-code?
+![B-arbre d'ordre 2.](figs/barbres_exemple.png)
 . . .
-```python
+## Oui!
-struct node
-    info
-    node sup_gauche, sup_droit,
-        inf_gauche, inf_droit
-```
-![Un nœud d'arbre quaternaire.](figs/quad_struct.svg)
+* Dans chaque nœud les clés sont **triées**.
+* Chaque page contient au plus $n$ nœuds: check;
+* Chaque nœud avec $m$ clés a $m+1$ descendants;
+* Toutes les feuilles apparaissent au même niveau.
-::::
+# Les B-arbres
-:::: {.column width=50%}
+## Exemple de recherche: trouver `32`
-## En C?
+![B-arbre d'ordre 2.](figs/barbres_exemple.png)
 . . .
-```C
+* Si `C` plus petit que la 1ère clé ou plus grand que la dernière descendre.
-struct _node {
+* Sinon parcourir (par bissection ou séquentiellement) jusqu'à trouver où descendre entre 2 éléments.
-    int info;
-    struct _node *sup_left;
-    struct _node *sup_right;
-    struct _node *inf_left;
-    struct _node *inf_right;
-};
-```
-* Pourquoi le `*` est important?
+# Les B-arbres
-. . .
+## Algorithme de recherche de la clé `C` 
-* Type récursif => taille inconnue à la compilation.
+0. En partant de la racine.
+1. Si on est dans une feuille:
+    * Si `C` est dans la page, retourner la page;
+    * Sinon c'est perdu.
+2. Sinon:
+    * Tant que `C < clé(page)` passer à la clé suivante
+    * Si `C` est dans la page, retourner la page;
+    * Sinon descendre
-::::
+# Les B-arbres
-:::
+## Disclaimer
-# Une fonctionnalité simple
+* Inspiration de <https://en.wikipedia.org/wiki/B-tree>
-\footnotesize
+## Exemples d'insertion: `1`
-## La fonction `est_feuille(noeud)`
+![B-arbre d'ordre 1.](figs/barbres_1.svg)
-* Problème avec cette implémentation?
-```python
-bool est_feuille(noeud) 
-    retourne
-        est_vide(sup_gauche(noeud)) &&
-        est_vide(sup_droit(noeud)) &&
-        est_vide(inf_gauche(noeud)) &&
-        est_vide(inf_droit(noeud))
-```
 . . .
-* Inutile d'avoir 4 conditions (soit 4 enfants soit aucun!)
+* L'arbre est vide, on insère juste dans la première page.
-* Facile d'en oublier un!
-* Comment changer la structure pour que ça soit moins terrible?
-. . .
+# Les B-arbres
-```python
+## Exemples d'insertion: `2`
-struct node
-    info
-    node enfant[4]
-```
-# Structure de données
+![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_2.svg)
-## En C?
 . . .
-```C 
+* La première page n'est pas pleine, on insère dans l'ordre (après 1).
-typedef struct _node {
-    int info;
-    struct _node *child[4];
-} node;
-```
-## Fonction `is_leaf(node *tree)`?
+# Les B-arbres
-. . .
+## Exemples d'insertion: `3`
-```C 
+![B-arbre d'ordre 1.](figs/barbres_2.svg){width=50%}
-bool is_leaf(node *tree) {
-    return (NULL == tree->child[0]); // only first matters
-}
-```
-# Problème à résoudre
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
-* Construire un arbre quaternaire à partir d'une image:
+# Les B-arbres
-    * Créer l'arbre (allouer la mémoire pour tous les nœuds),
-    * Le remplir avec les valeurs des pixels.
-* Compression de l'image:
-    * Si les pixels sont les mêmes dans le quadrant on supprime le sous-arbre (sans perte)
-    * Si les pixels dévient pas trop on supprime le quadrant (avec perte)
-# Création de l'arbre
+## Exemples d'insertion: `3`
-## Comment créer un arbre de profondeur `prof` (3min)?
+![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_3.svg){width=50%}
 . . .
-```python
+* La page est pleine, on crée deux enfants.
-arbre creer_arbre(prof)
+* On choisit, `2`, la médiane de `1, 2, 3` et il est inséré à la racine.
-    n = nouveau_noeud() # alloue la mémoire
+* `1` descend à gauche, `3` descend à droite.
-    si prof > 0
-        pour i = 0 à 3
-            n.enfant[i] = creer_arbre(prof-1)
-    retourne n
-```
-## En `C` (3 min, matrix)?
+# Les B-arbres
-. . .
+## Exemples d'insertion: `4`
-```C
+![B-arbre d'ordre 1.](figs/barbres_3.svg){width=50%}
-node *qt_create(int depth) {
-    node *n = calloc(1, sizeof(node));
-    if (depth > 0) {
-        for (int i = 0; i < 4; ++i) {
-            n->child[i] = qt_create(depth-1);
-        }
-    }
-    return n;
-}
-```
-# Le nombre de nœuds?
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
-## Comment implémenter la fonction (pseudo-code, 5min, matrix)?
+# Les B-arbres
-. . .
+## Exemples d'insertion: `4`
-```C
+![B-arbre d'ordre 1. Nombre enfants 0 ou 2.](figs/barbres_4.svg){width=50%}
-entier nombre_nœuds(arbre)
-    si est_feuille(arbre)
-        retourne 1
-    sinon
-        somme = 1
-        pour i de 0 à 3
-            somme += nombre_nœuds(arbre.enfant[i])
-        retourne somme
-```
-# Le nombre de nœuds?
-## Comment implémenter la fonction en C (3min, matrix)?
 . . .
-```C
+* On pourrait insérer à droite de `2`, mais... ça ferait 2 parents pour 2 enfants (mais `m` parents => `m+1` enfants ou `0`);
-int size(node *qt) {
+* On descend à droite (`4 > 2`);
-    if (is_leaf(qt)) {
+* On insère à droite de `3`.
-        return 1;
-    } else {
-        int sum = 1;
-        for (int i = 0; i < 4; ++i) {
-            sum += size(qt->child[i]);
-        }
-        return sum;
-    }
-}
-```
-# La profondeur en C?
-## Implémentation (5min, matrix)
+# Les B-arbres
-. . .
-\footnotesize
+## Exemples d'insertion: `5`
-```C
+![B-arbre d'ordre 1.](figs/barbres_4.svg){width=50%}
-int max(int x, int y) {
-   return  (x >= y ? x : y);
-}
-int max_depth(int depths[4]) {
-    int m = depths[0];
-    for (int i = 1; i < 4; ++i) {
-        m = max(m, depths[i]);
-    }
-    return m;
-}
-int depth(node *qt) {
-    int depths[] = {0, 0, 0, 0};
-    if (is_leaf(qt)) {
-        return 0;
-    } else {
-        for (int i = 0; i < 4; ++i) {
-            depths[i] = depth(qt->child[i]);
-        }
-        return 1 + max_depth(depths);
-    }
-}
-```
-# Fonctions utiles (1/4)
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
-## Comment remplir un arbre depuis une matrice?
+# Les B-arbres
-```
+## Exemples d'insertion: `5`
-   SG=0  |  SD=1
- 21 | 12 | 4 |  4
-  9 |  7 | 4 |  4
-----------------
-  1 |  1 | 0 | 31
-  1 |  1 | 3 | 27
-   IG=2  |  ID=3
-```
-## Quel arbre cela représente?
+![B-arbre d'ordre 1.](figs/barbres_5.svg)
 . . .
-![L'arbre correspondant](figs/quad_img_simple.svg)
+* On descend à droite (on ne peut pas insérer à la racine comme pour `4`);
+* On dépasse la capacité de l'enfant droite;
-# Fonctions utiles (2/4)
+* `4`, médiane de `3, 4, 5`, remonte à la racine;
+* On crée un nouveau nœud à droite de `4`;
+* La règle `m => m+1` est ok.
-* On veut transformer une ligne/colonne en feuille.
+# Les B-arbres
-* Comment?
-::: columns
+## Exemples d'insertion: `6`
-:::: {.column width=40%}
-## Soit `ligne=2`, `colonne=3`
-```
-   SG=0  |  SD=1
- 21 | 12 | 4 |  4
-  9 |  7 | 4 |  4
-----------------
-  1 |  1 | 0 | 31
-  1 |  1 | 3 | 27
-   IG=2  |  ID=3
-```
-::::
+![B-arbre d'ordre 1.](figs/barbres_5.svg){width=50%}
-:::: {.column width=70%}
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
-## Trouver un algorithme
+# Les B-arbres
-![Déterminer un algorithme.](figs/quad_img_simple.svg)
+## Exemples d'insertion: `6`
-* Quelle feuille pour 31 (`li=2`, `co=3`)?
+![B-arbre d'ordre 1.](figs/barbres_6.svg)
-* Plus important: quel chemin?
 . . .
-* `co -> G/D`, `li -> S/I`,
+* `6 > 4` on descend à droite;
-* `2 * (li / 2) + co / 2 -> 2 * 1 + 1 = 3`
+* `6 > 5` et on a à la place à droite, on insère.
-* `2 * ((li % 2) / 1) + (co % 2) / 1 -> 2 * 0 + 1 = 1`
-* Comment généraliser?
-::::
+# Les B-arbres
-:::
+## Exemples d'insertion: `7`
-# Fonctions utiles (3/4)
+![B-arbre d'ordre 1.](figs/barbres_6.svg){width=50%}
-::: columns
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
-:::: {.column width=40%}
+# Les B-arbres
-## Soit `ligne=2`, `colonne=3`
+## Exemples d'insertion: `7`
-```
+![B-arbre d'ordre 1.](figs/barbres_7.svg){width=50%}
-   SG=0  |  SD=1
- 21 | 12 | 4 |  4
-  9 |  7 | 4 |  4
-----------------
-  1 |  1 | 0 | 31
-  1 |  1 | 3 | 27
-   IG=2  |  ID=3
-```
-::::
-:::: {.column width=70%}
-## Trouver un algorithme (prendre plusieurs exemples, 15min, matrix)
-![Déterminer un algorithme.](figs/quad_img_simple.svg)
-* Comment généraliser?
 . . .
-```C
+* `7 > 4` on descend à droite;
-noeud position(li, co, arbre)
+* `7 > 6` mais on a dépassé la capacité;
-    d = profondeur(arbre);
+* `6` est la médiane de `5, 6, 7`, remonte à la racine;
-    tant_que (d >= 1)
+* `5` reste à gauche, `7` à droite, mais `6` fait dépasser la capacité de la racine;
-        index = 2 * ((li % 2^d) / 2^(d-1)) +
+* `4` est la médiane de `2, 4, 6`, `4` remonte, `2` reste à gauche, `6` à droite.
-            (col % 2^d) / 2^(d-1)
-        arbre = arbre.enfant[index]
-        d -= 1
-    retourne arbre
-```
-::::
-:::
-# Fonctions utiles (4/4)
-\footnotesize
-## Pseudo-code
-```C
-noeud position(li, co, arbre)
-    d = profondeur(arbre);
-    tant_que (d >= 1)
-        index = 2 * ((li % 2^d) / 2^(d-1)) +
-            (col % 2^d) / 2^(d-1)
-        arbre = arbre.enfant[index]
-        d -= 1
-    retourne arbre
-```
-## Écrire le code `C` correspondant (5min, matrix)
-```C
+# Les B-arbres
+## L'algorithme d'insertion
+0. Rechercher la feuille (la page n'a aucun enfant) où insérer;
+1. Si la page n'est pas pleine insérer dans l'ordre croissant.
+2. Si la page est pleine, on sépare la page en son milieu :
+    1. On trouve la médiane, `M`, de la page;
+    2. On met les éléments `< M` dans la page de gauche de `M` et les `> M` dans la page de droite de `M`;
+    3. `M` est insérée récursivement dans la page parent.
+# Les B-arbres
+## Exercice: insérer `22, 45, 50` dans l'arbre d'ordre 2 (3min matrix)
+![](figs/barbres_ex1.png)
+. . .
+![](figs/barbres_ex2.png)
-```
+# Les B-arbres
-# Remplir l'arbre
+## Exercice: insérer `5` dans l'arbre d'ordre 2 (3min matrix)
-## A partir d'une matrice (pseudo-code, 5min, matrix)?
+![](figs/barbres_ex2.png)
 . . .
-```C
+![](figs/barbres_ex3.png)
-arbre matrice_à_arbre(matrice)
-    arbre = creer_arbre(profondeur)
-    pour li de 0 à nb_lignes(matrice)
-        pour co de 0 à nb_colonnes(matrice)
-            noeud = position(li, co, arbre)
-            noeud.info = matrice[co][li]
-    retourne arbre
-```
-. . .
-## A partir d'une matrice (C, 5min, matrix)?
+# Les B-arbres
-. . .
+## Exercice: insérer `32, 55, 60` dans l'arbre d'ordre 2 (3min matrix)
-\footnotesize
+![](figs/barbres_ex3.png)
-```C
-node *matrix_to_qt(int nb_li, int nb_co, int matrix[nb_li][nb_co], int depth)
-{
-    node *qt = qt_create(depth);
-    for (int li = 0; li < nd_li; ++li) {
-        for (int co = 0; co < nd_co; ++co) {
-            node *current = position(li, co, qt);
-            current->info = matrix[li][co];
-        }
-    }
-    return qt;
-}
-```
+. . .
-# Remplir la matrice
+![](figs/barbres_ex4.png)
-## A partir de l'arbre (pseudo-code, 3min, matrix)?
+# Les B-arbres
-. . .
+## Exercice: insérer `41` dans l'arbre d'ordre 2 (3min matrix)
-```C
+![](figs/barbres_ex4.png)
-matrice arbre_à_matrice(arbre)
-    matrice = creer_matrice(nb_lignes(arbre), nb_colonnes(arbre))
-    pour li de 0 à nb_lignes(matrice)
-        pour co de 0 à nb_colonnes(matrice)
-            noeud = position(li, co, arbre)
-            matrice[co][li] = noeud.info
-    retourne matrice
-```
 . . .
-## A partir de l'arbre (C, 3min, matrix)?
+![](figs/barbres_ex5.png)
-. . .
+# Les B-arbres
-\footnotesize
-```C
+## Exercice (matrix, 15min)
-void qt_to_matrix(node *qt, int nb_li, int nb_co, int matrix[nb_li][nb_co])
-    for (int li = 0; li < nd_li; ++li) {
-        for (int co = 0; co < nd_co; ++co) {
-            node *current = position(li, co, qt);
-            matrix[li][co] = current->info;
-        }
-    }
-```
-# Transformations avec un arbre quaternaire
+* Insérer 20, 40, 10, 30, 15, 35, 7, 26, 18, 22, 5, 42, 13, 46, 27, 8, 32, 38, 24, 45, 25, 2, 14, 28, 32, 41,
+* Dans un B-arbre d'ordre 2.
-## A faire
+# Les B-arbres
-* Symétrie axiale (horizontale/verticale).
+\footnotesize
-* Rotation quart de cercle (gauche/droite).
-* Compression.
-# La symétrie verticale
+## Structure de données
-## Que donne la symétrie verticale de
+* Chaque page a une contrainte de remplissage, par rapport à l'ordre de l'arbre;
+* Un nœud (page) est composé d'un tableau de clés/pointeurs vers les enfants;
 ```
-   SG=0  |  SD=1
+P_0 | K_1 | P_1 | K_2 | .. | P_i | K_{i+1} | .. | P_{m-1} | K_m | P_m
- 21 | 12 | 4 |  4
-  9 |  7 | 4 |  4
-----------------
-  1 |  1 | 0 | 31
-  1 |  1 | 3 | 27
-   IG=2  |  ID=3
 ```
-. . .
+* `P_0`, ..., `P_m` pointeurs vers enfants;
+* `K_1`, ..., `K_m` les clés.
-```
+* Il y a `m+1` pointeurs mais `m` clés.
-   SG=0  |  SD=1
+* Comment faire pour gérer l'insertion?
-  4 |  4 | 12 | 21
-  4 |  4 |  7 |  9
------------------
- 31 |  0 |  1 |  1
- 27 |  3 |  1 |  1
-   IG=2  |  ID=3
-```
-# La symétrie d'axe vertical
+# Les B-arbres
-## Comment faire sur une matrice (3min, matrix)?
+## Faire un dessin de la structure de données (3min matrix)?
 . . .
-\footnotesize
+![Structure d'une page de B-arbre d'ordre 2.](figs/barbres_struct.png)
-```C
+1. On veut un tableau de `P_i, K_i => struct`;
-matrice symétrie(matrice)
+2. `K_0` va être en "trop";
-    pour i de 0 à nb_colonnes(matrice) / 2
+3. Pour simplifier l'insertion dans une page, on ajoute un élément de plus.
-        pour j de 0 à nb_lignes(matrice)
-            échanger(matrice[i][j], matrice[nb_colonnes(matrice)-1-i][j])
-    retourne matrice
-```
-# La symétrie d'axe vertical
-## Comment faire sur un arbre?
+# Les B-arbres
-* Faire un dessin de l'arbre avant/après (5min, matrix)
+## L'insertion cas nœud pas plein, insertion `4`?
-    ```
+![](figs/barbres_insert_easy.svg){width=50%}
-       SG=0  |  SD=1        SG=0  |  SD=1        
-     21 | 12 | 4 |  4       4 | 4 | 12 | 21
-      9 |  7 | 4 |  4       4 | 4 |  7 |  9
-    -----------------  =>  ----------------
-      1 |  1 | 0 | 31      31 | 0 |  1 |  1
-      1 |  1 | 3 | 27      27 | 3 |  1 |  1
-       IG=2  |  ID=3        IG=2  |  ID=3
-    ```
-* Écrire le pseudo-code (3min, matrix)
 . . .
-\footnotesize
+## Solution
-```C
+![](figs/barbres_insert_easy_after.svg){width=50%}
-arbre symétrie(arbre)
-    si !est_feuille(arbre)
-        échanger(arbre.enfant[0], arbre.enfant[1])
-        échanger(arbre.enfant[2], arbre.enfant[3])
-        pour i de 0 à 3
-            symétrie(arbre.enfant[i])
-    retourne arbre
-```
-# La symétrie d'axe horizontal
+# Les B-arbres
-* Trivial de faire l'axe horizontal (exercice à la maison)
+## L'insertion cas nœud pas plein, insertion `N`
-# Rotation d'un quart de cercle
+* On décale les éléments plus grand que `N`;
+* On insère `N` dans la place "vide";
+* Si la page n'est pas pleine, on a terminé.
-## Comment faire sur un arbre?
+# Les B-arbres
-* Faire un dessin de l'arbre avant/après (5min, matrix)
+## L'insertion cas nœud plein, insertion `2`?
-    ```
+![](figs/barbres_insert_hard_before.svg){width=50%}
-       SG=0  |  SD=1        SG=0  |  SD=1   
-     21 | 12 | 4 |  4      4 |  4 | 31 | 27
-      9 |  7 | 4 |  4      4 |  4 |  0 |  3
-    -----------------  => ----------------- 
-      1 |  1 | 0 | 31     12 |  7 |  1 |  1
-      1 |  1 | 3 | 27     21 |  9 |  1 |  1
-       IG=2  |  ID=3        IG=2  |  ID=3
-    ```
-* Écrire le pseudo-code (3min, matrix)
 . . .
-```C
+## Solution
-rien rotation_gauche(arbre) 
-    si !est_feuille(arbre)
-        échange_cyclique_gauche(arbre.enfant)
-        pour i de 0 à 3
-            rotation_gauche(arbre.enfant[i])
-```
-# Rotation d'un quart de cercle
+![](figs/barbres_insert_hard_during.svg){width=50%}
-\footnotesize
+# Les B-arbres
-## Comment faire sur un arbre?
+## L'insertion cas nœud plein, promotion `3`?
-```
+![](figs/barbres_insert_hard_during.svg){width=50%}
-   SG=0  |  SD=1        SG=0  |  SD=1   
- 21 | 12 | 4 |  4      4 |  4 | 31 | 27
-  9 |  7 | 4 |  4      4 |  4 |  0 |  3
-----------------  => ----------------- 
-  1 |  1 | 0 | 31     12 |  7 |  1 |  1
-  1 |  1 | 3 | 27     21 |  9 |  1 |  1
-   IG=2  |  ID=3        IG=2  |  ID=3
-```
-* Écrire le vrai (5min, matrix)
 . . .
-```C
+## Solution
-void rotate(node *qt) {
-    if (!is_leaf(qt)) {
-        node *tmp = qt->child[2];
-        qt->child[2] = qt->child[0];
-        qt->child[0] = qt->child[1];
-        qt->child[1] = qt->child[3];
-        qt->child[3] = tmp;
-        for (int i=0;i < 4; i++) { 
-            rotate(qt->child[i]);
-        }
-    }
-}
-```
-# Compression sans perte (1/5)
-## Idée générale
+![](figs/barbres_insert_hard_after.svg)
-* Regrouper les pixels par valeur
+# Les B-arbres
-```
+## L'insertion cas nœud plein, insertion `N`
-   SG=0  |  SD=1        SG=0   |  SD=1   
- 21 | 12 | 4 |  4      21 | 12 |   4
-  9 |  7 | 4 |  4       9 |  7 |  
-----------------  => ----------------- 
-  1 |  1 | 0 | 31         1    |  0 | 31
-  1 |  1 | 3 | 27              |  3 | 27
-   IG=2  |  ID=3        IG=2   |  ID=3
-```
-* Comment faire?
+* On décale les éléments plus grand que `N`;
+* On insère `N` dans la place "vide";
+* Si la page est pleine:
+    * On trouve la valeur médiane `M` de la page (quel indice?);
+    * On crée une nouvelle page de droite;
+    * On copie les valeurs à droite de `M` dans la nouvelle page;
+    * On promeut `M` dans la page du dessus;
+    * On connecte le pointeur de gauche de `M` et de droite de `M` avec l'ancienne et la nouvelle page respectivement.
-# Compression sans perte (2/5)
+# Les B-arbres
-## Que devient l'arbre suivant?
+## Pseudo-code structure de données (3min, matrix)?
-![](figs/quad_img_simple.svg)
-. . . 
-## Arbre compressé
-![](figs/quad_img_simple_comp.svg)
-# Compression sans perte (3/5)
-* Si un nœud a tous ses enfants égaux:
-    * Donner la valeur au nœud,
-    * Supprimer les enfants.
-* Remonter jusqu'à la racine.
-## Écrire le pseudo-code (5min, matrix)
 . . .
 ```C
-rien compression_sans_pertes(arbre)
+struct page
-    si !est_feuille(arbre)
+    entier ordre, nb
-        pour i de 0 à 3
+    element tab[2*ordre + 2]
-            compression_sans_pertes(arbre.enfant[i])
-        si derniere_branche(arbre)
-            valeur, toutes_égales = valeur_enfants(arbre)
-            si toutes_egales
-                arbre.info = valeur
-                detruire_enfants(arbre)
 ```
-# Compression sans perte (4/5)
-\footnotesize
-## Écrire le code C (5min, matrix)
-. . .
 ```C
-void lossless_compression(node *qt) {
+struct element
-    if (!is_leaf(qt)) {
+    entier clé
-        for (int i = 0; i < CHILDREN; i++) {
+    page pg
-            lossless_compression(qt->child[i]);
-        }
-        if (is_last_branch(qt)) {
-            int val = -1;
-            if (last_value(qt, &val)) {
-                qt->info = val;
-                for (int i = 0; i < 4; ++i) {  
-                    free(qt->child[i]);
-                    qt->child[i] = NULL;
-                }
-            }
-        }
-    }
-}
 ```
-# Compression sans perte (5/5)
+# Les B-arbres
 \footnotesize
-```C
+## Les fonctions utilitaires (5min matrix)
-bool is_last_branch(node *qt) {
-    for (int i = 0; i < 4; ++i) {
-        if (!is_leaf(qt)) {
-            return false;
-        }
-    }
-    return true;
-}
-bool last_value(node *qt, int *val) {
-    int info = qt->child[0];
-    for (int i = 1; i < 4; ++i) {
-        if (info != qt->child[i]) {
-            return false;
-        }
-    }
-    *val = info;
-    return true;
-}
-```
-# Compression avec perte (1/5)
-## Idée générale
+```C
+booléen est_feuille(page)     // la page est elle une feuille?
-* Regrouper les pixels par valeur sous certaines conditions
+entier position(page, valeur) // à quelle indice on insère?
+booléen est_dans_page(page, valeur) // la valeur est dans la page
-```
-   SG=0  |  SD=1        SG=0   |  SD=1   
- 21 | 12 | 4 |  3      21 | 12 |    4
-  9 |  7 | 4 |  4       9 |  7 |  
-----------------  => ------------------
-  1 |  1 | 0 | 31         1    |  0 | 31
-  2 |  1 | 3 | 27              |  3 | 27
-   IG=2  |  ID=3        IG=2   |  ID=3
 ```
-* On enlève si l'écart à la moyenne est "petit"?
-# Compression avec perte (2/5)
-## Que devient l'arbre suivant si l'écart est petit?
-![](figs/quad_img_simple_variation.svg)
 . . .
-## Arbre compressé
-![](figs/quad_img_simple_comp_loss.svg)
-# Compression avec perte (3/5)
-## Comment mesurer l'écart à la moyenne?
-. . .
-* Avec l'écart-type
-\begin{equation*}
-\mu = \frac{1}{4}\sum_{i=0}^{3} p[i],\quad \sigma = \sqrt{\frac{1}{4}\sum_{i=0}^3 (\mu-p[i])
-^2} = \sqrt{\frac{1}{4}\left(\sum_{i=0}^3p[i]^2\right)-\mu^2}
-\end{equation*}
-## Que devient l'algorithme?
-. . .
-* Si $\sigma<\theta$, $\theta$ est la **tolérance**:
-    * Remplacer la valeur du pixel par la moyenne des enfants.
-    * Remonter les valeurs dans l'arbre.
-## Quelle influence de la valeur de $\theta$ sur la compression?
-. . .
-* Plus $\theta$ est grand, plus l'image sera compressée.
-# Compression avec perte (4/5)
-## Que devient l'arbre avec $\theta=0.5$?
-![L'arbre original.](figs/quad_img_simple_variation.svg)
-. . .
-![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)
-# Compression avec perte (5/5)
-## Modifications sur la structure de données?
-. . .
-* On stocke la moyenne, et la moyenne des carrés.
 ```C
-struct noeud
+booléen est_feuille(page) 
-    flottant moyenne, moyenne_carre
+    retourne (page.tab[0].pg == vide)
-    node enfants[4]
-```
-* Comment on calcule `moyenne` et `moyenne_carre` sur chaque nœud (pseudo-code)?
-# Calcul de la moyenne
+entier position(page, valeur)
+    i = 0
+    tant que i < page.nb && valeur >= page.tab[i+1].clef
+        i += 1
+    retourne i
-## Pseudo-code (5min, matrix)
+booléen est_dans_page(page, valeur)
+    i = position(page, valeur)
-. . .
+    retourne (page.nb > 0 && page.tab[i].val == valeur)
-```C
-rien moyenne(arbre) {
-    si !est_feuille(arbre)
-        pour enfant dans arbre.enfants
-            moyenne(enfant)
-        pour enfant dans arbre.enfants
-            arbre.moyenne += enfant.moyenne
-            arbre.moyenne_carre += enfant.moyenne_carre
-        arbre.moyenne /= 4
-        arbre.moyenne_carre /= 4
 ```
-# La compression avec pertes
+# Les B-arbres
 \footnotesize
-## Pseudo-code (5min, matrix)
+## Les fonctions utilitaires (5min matrix)
-. . .
 ```C
-rien compression_avec_pertes(arbre, theta)
+page nouvelle_page(ordre)  // créer une page
-    si !est_feuille(arbre)
+rien liberer_memoire(page) // libérer tout un arbre!
-        pour i de 0 à 3
-            compression_avec_pertes(arbre.enfant[i])
-        si derniere_branche(arbre)
-            si racine(arbre.moyenne_carre - arbre.moyenne^2) < theta
-                detruire_enfants(arbre)
 ```
+. . .
-## Le code en entier
 ```C
-arbre = matrice_à_arbre(matrice)
+page nouvelle_page(ordre)
-moyenne(arbre)
+    page = allouer(page)
-compression_avec_pertes(arbre)
+    page.ordre = ordre
+    page.nb = 0
+    page.tab = allouer(2*ordre+2)
+    retourner page
+rien liberer_memoire(page)
+    si est_feuille(page)
+        liberer(page.tab)
+        liberer(page)
+    sinon
+        pour fille dans page.tab
+            liberer_memoire(fille)
+        liberer(page.tab)
+        liberer(page)
 ```
-# La dynamique des corps célestes
+# Les B-arbres
-## Slides très fortement inspirés du cours de J. Latt, Unige
-## Simulation du problème à $N$-corps
-* Prédiction du mouvement d'un grand nombre de corps célestes.
+## Les fonctions (5min matrix)
-* Modélisation:
-    * On se limite aux étoiles;
-    * Chaque étoile est caractérisée par un point (coordonnées) et une masse;
-    * On simule en deux dimensions.
-    * Interactions uniquement par les lois de la gravitation Newtonienne (oui-oui c'est de la **physique**!).
-# Les équations du mouvement
-## Mouvement de la $i$-ème étoile
-* Algorithme de Verlet ($t_{n+1}=t_n+\delta t$)
-    $$
-   \vec x_i(t_{n+1})= 2\vec x_i(t_n)-\vec x_i(t_{n-1})+\vec a_i(t_n)\delta t^2.
-   $$
-## Force de gravitation
-* $\vec a_i(t_n)=\vec F_i/m_i$.
-* Sur l'étoile $i$, la force résultante est donnée par
-    $$
-    \vec F_i=\sum_{j=1,j\neq i}^N \vec F_{ij}.
-    $$
-    avec
-    $$
-    \vec F_{ij}=\frac{G m_i m_j(\vec x_j-\vec x_i)}{||\vec x_j-\vec x_i||^3}.
-    $$
-# Algorithme du problème à $n$-corps
-## Pseudo-code: structure de données
 ```C
-struct étoile
+page recherche(page, valeur) // retourner la page contenant
-    flottant m
+                             // la valeur ou vide 
-    vec x, x_precedent, f
 ```
-## Pseudo-code: itération temporelle
+. . .
 ```C
-rien iteration_temporelle(étoiles, dt)
+page recherche(page, valeur)
-    pour étoile_une dans étoiles
+    si est_dans_page(page, valeur)
-        étoile_une.f = 0
+        retourne page
-        pour étoile_deux dans étoiles
+    sinon si est_feuille(page) 
-            si (étoile_un != étoile_deux)
+        retourne vide
-                étoile_une.f += 
+    sinon
-                    force(étoile_une, étoile_deux)
+        recherche(page.tab[position(page, valeur) - 1], valeur)
-    pour étoile dans étoiles
-        étoile.x, étoile.x_precedent = 
-            verlet(étoile.x, étoile.x_precedent, 
-                   étoile.f / étoile.m, dt)
 ```
-# Algorithme du problème à $n$-corps
-## Complexité
-* Complexité de chacune des parties?
-. . .
-* $\mathcal{O}(N^2)$, $\mathcal{O}(N)$.
-## En temps CPU pour **une itération**
-\footnotesize
-* Si temps pour $N=1$ on calcule en $1\mu s$:
-+--------+-------+-------+-----------+
-|     N  |  N^2  | t [s] | t [réel]  |
-+--------+-------+-------+-----------+
-|    10  |  10^2 | 1e-4  |           |
-+--------+-------+-------+-----------+
-|  10^4  |  10^8 | 1e+2  | ~1min     |
-+--------+-------+-------+-----------+
-|  10^6  | 10^12 | 1e+6  | ~11j      |
-+--------+-------+-------+-----------+
-|  10^9  | 10^18 | 1e+12 | ~30k ans  |
-+--------+-------+-------+-----------+
-|  10^11 | 10^22 | 1e+16 | ~300M ans |
-+--------+-------+-------+-----------+
-* Typiquement il y a des milliers-millions d'itérations.
-* Il y a $10^{11}$ étoiles dans la galaxie.
-* Houston we have a problem.
-# Question
-## Comment faire mieux, des idées?
-. . .
-* Si un groupe d'étoiles est suffisamment loin, on le modélise comme un corps unique situé en son centre de masse.
-* Exemple: Si on simule plusieurs galaxies, on considère chaque galaxie comme un corps unique!
-* Un arbre quaternaire est une structure parfaite pour regrouper les étoiles.
-# Le cas à 10 corps
-::: columns
-:::: {.column width=50%}
-## Illustration: le cas à 10 corps
-![](figs/nbody_bare.png){width=60%}
-::::
-:::: {.column width=50%}
-## Problématique
-* On veut calculer la force sur $1$.
-::::
-:::
-. . .
-::: columns
-:::: {.column width=50%}
-## Illustration: le cas à 10 corps
-![](figs/nbody_n2.png){width=60%}
-::::
-:::: {.column width=50%}
-## Résultat
-* Calcul et somme des forces venant des $9$ autre corps.
-::::
-:::
-# Le cas à 10 corps
-::: columns
-:::: {.column width=50%}
-## Réduction d'un groupe à un seul corps
-![](figs/nbody_group.png){width=100%}
-::::
-:::: {.column width=50%}
-## Idée
-* On accélère le calcul en traitant un groupe comme un seul corps.
-* Fonctionne uniquement si le groupe est assez loin.
-* Autrement l'approximation est trop grossière.
-::::
-:::
-# Solution: l'arbre quaternaire
-## Corps célestes - arbre
-![](figs/nbody_qt_withtree.png)
-* On omet les nœuds vides pour éviter la surcharge.
-* La numérotation est:
-    * 0: ID
-    * 1: SD
-    * 2: IG
-    * 3: SG
-# Exemple d'insertion
-::: columns
-:::: {.column width=50%}
-## Insertion corps 1
-![](figs/corps1.png){width=100%}
-::::
-:::: {.column width=50%}
-## Arbre, niveau 1
-![](figs/arbre1.png){width=100%}
-* Quadrant ID.
-* La feuille est vide, on insère.
-::::
-:::
-# Exemple d'insertion
-::: columns
-:::: {.column width=50%}
-## Insertion corps 2
-![](figs/corps2.png){width=100%}
-::::
-:::: {.column width=50%}
-## Arbre, niveau 1
-![](figs/arbre2.png){width=100%}
-* Quadrant SD.
-* La feuille est vide, on insère.
-::::
-:::
-# Exemple d'insertion
-::: columns
-:::: {.column width=50%}
-## Insertion corps 3 (1/N)
-![](figs/corps3_1.png){width=100%}
-::::
-:::: {.column width=50%}
-## Arbre, niveau 1
-![](figs/arbre3_1.png){width=100%}
-* Quadrant SD.
-* La feuille est prise par 2.
-::::
-:::
-# Exemple d'insertion
-::: columns
-:::: {.column width=50%}
-## Insertion corps 3 (2/N)
-![](figs/corps3_2.png){width=100%}
-::::
-:::: {.column width=50%}
-## Arbre, niveau 2
-![](figs/arbre3_2.png){width=100%}
-* On crée un nouveau nœud.
-* Deux corps dans le nœud ID.
-* On crée un nouveau nœud.
-::::
-:::
-# Exemple d'insertion
-::: columns
-:::: {.column width=50%}
-## Insertion corps 3 (3/N)
-![](figs/corps3_3.png){width=100%}
-::::
-:::: {.column width=50%}
-## Arbre, niveau 3
-![](figs/arbre3_3.png){width=100%}
-* 2 va dans ID.
-* 3 va dans SG.
-* C'est des feuilles vides, tout va bien.
-::::
-:::
-# Exemple d'insertion
-::: columns
-:::: {.column width=50%}
-## Que fait-on avec les nœuds intérieurs?
-* On les utilise pour:
-    * stocker la masse totale;
-    * stocker le centre de masse.
-\begin{align}
-m&=m_2+m_3,\\
-\vec x &= \frac{m_2\vec x_2+m_3\vec x_3}{m}.
-\end{align}
-## Chaque feuille contient **une étoile**
-::::
-:::: {.column width=50%}
-## Arbre
-![](figs/arbre3_3.png){width=100%}
-::::
-:::
-# Résumé
-* Insertion du corps `c` dans le nœud `n` en partant de la racine.
-* Si le nœud `n`
-    * ne contient pas de corps, on y dépose `c`,
-    * est interne, on met à jour masse et centre de masse. `c` est inséré récursivement dans le bon quadrant.
-    * est externe, on subdivise `n`, on met à jour la masse et centre de masse, on insère récursivement les deux nœuds dans les quadrants appropriés.
-## Remarque
-* Il faut stocker les coordonnées des quadrants.
-* Un nœud a un comportement différent s'il est interne ou externe.
--- a/slides/cours_22.md
+++ b/slides/cours_22.md
+---
+title: "Les B-arbres"
+date: "2025-05-09"
+---
+# Les B-arbres (rappel)
+## Définition: B-arbre d'ordre $n$
+. . .
+* Chaque page d'un arbre contient au plus $2\cdot n$ *clés*;
+* Chaque page (excepté la racine) contient au moins $n$ clés;
+* Chaque page qui contient $m$ clés contient soit:
+    * $0$ descendants;
+    * $m+1$ descendants.
+* Toutes les pages terminales apparaissent au même niveau.
+# Les B-arbres (rappel)
+## Est-ce un B-arbre?
+![B-arbre d'ordre 2.](figs/barbres_exemple.png)
+. . .
+### Bien sûr!
+# Les B-arbres (rappel)
+## L'algorithme d'insertion
+. . .
+0. Rechercher la feuille (la page a aucun enfant) où insérer;
+1. Si la page n'est pas pleine, insérer dans l'ordre croissant.
+2. Si la page est pleine, on sépare la page en son milieu :
+    1. On trouve la médiane, `M`, de la page;
+    2. On met les éléments `< M` dans la page de gauche de `M` et les `> M` dans la page de droite de `M`;
+    3. `M` est insérée récursivement dans la page parent.
+# Les B-arbres (rappel)
+## L'insertion cas nœud pas plein, insertion `4`?
+![](figs/barbres_insert_easy.svg){width=50%}
+. . .
+## Solution
+![](figs/barbres_insert_easy_after.svg){width=50%}
+# Les B-arbres (rappel)
+## L'insertion cas nœud pas plein, insertion `N`
+* On décale les éléments plus grand que `N`;
+* On insère `N` dans la place "vide";
+* Comme la page ne déborde pas, on a terminé.
+# Les B-arbres (rappel)
+## L'insertion cas nœud plein, insertion `2`?
+![](figs/barbres_insert_hard_before.svg){width=50%}
+. . .
+## Solution
+![](figs/barbres_insert_hard_during.svg){width=50%}
+# Les B-arbres (rappel)
+## L'insertion cas nœud plein, promotion `3`?
+![](figs/barbres_insert_hard_during.svg){width=50%}
+. . .
+## Solution
+![](figs/barbres_insert_hard_after.svg)
+# Les B-arbres (rappel)
+## L'insertion cas nœud plein, insertion `N`
+* On décale les éléments plus grands que `N`;
+* On insère `N` dans la place "vide";
+* Si la page est pleine:
+    * On trouve la valeur médiane `M` de la page (quel indice?);
+    * On crée une nouvelle page de droite;
+    * On copie les valeurs à droite de `M` dans la nouvelle page;
+    * On promeut `M` dans la page du dessus;
+    * On connecte le pointeur de gauche de `M` et de droite de `M` avec l'ancienne et la nouvelle page respectivement.
+# Les B-arbres (rappel)
+## Pseudo-code structure de données
+. . .
+```C
+struct page
+    entier ordre, nb
+    element tab[2*ordre + 2]
+```
+```C
+struct element
+    entier clé
+    page pg
+```
+# Les B-arbres (rappel)
+\footnotesize
+## Les fonctions utilitaires (5min matrix)
+```C
+booléen est_feuille(page)     // la page est-elle une feuille?
+entier position(page, valeur) // à quelle indice insère-t-on?
+booléen est_dans_page(page, valeur) // la valeur est-elle dans la page?
+```
+. . .
+```C
+booléen est_feuille(page) 
+    retourne (page.tab[0].pg == vide)
+entier position(page, valeur)
+    i = 0
+    tant que i < page.nb && valeur >= page.tab[i+1].clef
+        i += 1
+    retourne i
+booléen est_dans_page(page, valeur)
+    i = position(page, valeur)
+    retourne (page.nb > 0 && page.tab[i].val == valeur)
+```
+# Les B-arbres (rappel)
+\footnotesize
+## Les fonctions utilitaires 
+```C
+page nouvelle_page(ordre)  // créer une page
+```
+. . .
+```C
+page nouvelle_page(ordre)
+    page = allouer(page)
+    page.ordre = ordre
+    page.nb = 0
+    page.tab = allouer(2*ordre+2)
+    retourner page
+```
+# Les B-arbres (rappel)
+## Recherche de page
+```C
+page recherche(page, valeur) // retourner la page contenant
+                             // la valeur ou vide 
+```
+. . .
+```C
+page recherche(page, valeur)
+    si est_dans_page(page, valeur)
+        retourne page
+    sinon si est_feuille(page) 
+        retourne vide
+    sinon
+        recherche(page.tab[position(page, valeur) - 1], 
+            valeur)
+```
+# Les B-arbres (nouveautés)
+## Les fonctions
+```C
+page inserer_valeur(page, valeur) // insérer une valeur
+```
+. . .
+```C
+page inserer_valeur(page, valeur)
+    element = nouvel_element(valeur)
+    // ici élément est modifié pour savoir 
+    // s'il faut le remonter
+    inserer_element(page, element) 
+    si element.page != vide && page.nb > 2*page.ordre
+        // si on atteint le sommet!
+        page = ajouter_niveau(page, element) 
+    retourne page
+```
+# Les B-arbres
+## Les fonctions
+```C
+rien inserer_element(page, element) // insérer un element 
+                                    // et voir s'il remonte
+```
+. . .
+```C
+rien inserer_element(page, element)
+    si est_feuille(page)
+        placer(page, element)
+    sinon
+        sous_page = 
+            page.tab[position(page, element.clé) - 1].page
+        inserer_element(sous_page, element)
+        // un element a été promu
+        si element.page != vide
+            placer(page, element)
+```
+# Les B-arbres
+## Les fonctions (5min matrix)
+```C
+rien placer(page, element) // inserer un element
+```
+. . .
+```C
+rien placer(page, element)
+    pos = position(page, element.clé)
+    pour i de 2*page.ordre à pos+1
+        page.tab[i+1] = page.tab[i]
+    page.tab[pos+1] = element
+    page.nb += 1
+    si page.nb > 2*page.ordre
+        scinder(page, element)
+```
+# Les B-arbres
+## Les fonctions (5min matrix)
+```C
+rien scinder(page, element) // casser une page et remonter
+```
+. . .
+```C
+rien scinder(page, element)
+    nouvelle_page = nouvelle_page(page.ordre)
+    nouvelle_page.nb = page.ordre
+    pour i de 0 à ordre inclu
+        nouvelle_page.tab[i] = page.tab[i+ordre+1]
+    element.clé = page.tab[ordre+1].clé
+    element.page = nouvelle_page
+```
+# Les B-arbres
+## Les fonctions (5min matrix)
+```C
+page ajouter_niveau(page, element) // si on remonte à la 
+                                   // racine, on doit créer
+                                   // une nouvelle racine
+```
+. . .
+```C
+page ajouter_niveau(page, element) 
+    tmp = nouvelle_page(page.ordre)
+    tmp.tab[0].page = page
+    tmp.tab[1].clé = element.clé
+    tmp.tab[1].page = element.page
+    retourne tmp
+```
+<!-- # Les B-arbres -->
+<!-- ## Structure de données en C (3min, matrix) -->
+<!-- . . . -->
+<!-- ```C -->
+<!-- typedef struct _page { -->
+<!--     int order, nb; -->
+<!--     struct _element *tab; -->
+<!-- } page; -->
+<!-- ``` -->
+<!-- ```C -->
+<!-- typedef struct element { -->
+<!--     int key; -->
+<!--     struct _page *pg; -->
+<!-- } element; -->
+<!-- ``` -->
+# Les B-arbres: suppression
+## Cas simplissime
+![Suppression de 25.](figs/barbres_ordre2_supp1.svg){width=80%}
+. . .
+![25 supprimé, on décale juste 27.](figs/barbres_ordre2_supp2.svg){width=80%}
+# Les B-arbres: suppression
+\footnotesize
+## Cas simple
+![Suppression de 27.](figs/barbres_ordre2_supp2.svg){width=50%}
+. . .
+* On retire 27, mais....
+    * Chaque page doit avoir au moins 2 éléments.
+    * On doit déplacer des éléments dans une autre feuille! Mais comment?
+. . .
+![La médiane de la racine descend, fusion de 20 à gauche, et suppression à droite.](figs/barbres_ordre2_supp3.svg){width=60%}
+# Les B-arbres: suppression
+## Cas moins simple
+![Suppression de 5.](figs/barbres_ordre2_supp4.svg){width=50%}
+. . .
+* Un élément à droite, comment on fait?
+    * Remonter `7`, serait ok si racine, mais... ce n'est pas forcément le cas.
+    * On redistribue les feuilles.
+. . .
+![Descente de `3`, remontée médiane des feuilles `2`.](figs/barbres_ordre2_supp5.svg){width=50%}
+# Les B-arbres: suppression
+\footnotesize
+## Cas ultra moins simple
+![Suppression de 3.](figs/barbres_ordre2_supp6.svg){width=60%}
+. . .
+* `7` seul:
+    * Fusionner les feuilles et redistribuer, comment?
+. . .
+![Descendre `-1`, déplacer `7` à gauche, et décaler les éléments de droite au milieu.](figs/barbres_ordre2_supp7.svg){width=60%}
+# Les B-arbres: suppression
+## Cas ultra moins simple
+![On a pas fini...](figs/barbres_ordre2_supp7.svg){width=60%}
+. . .
+* `8` est seul, ce n'est plus un B-arbre :
+    * Fusionner le niveau 2 et redistribuer, comment?
+. . .
+![Fusionner `8`, `17`, `22` et descendre `12`.](figs/barbres_ordre2_supp8.svg){width=40%}
+. . .
+* La profondeur a diminué de 1.
+# Les B-arbres: suppression
+## Algorithme pour les feuilles!
+* Si la clé est supprimée d'une feuille:
+    * Si on a toujours `n` (ordre de l'arbre) clés dans la feuille, on décale simplement les clés.
+    * Sinon on combine (récursivement) avec le nœud voisin et on descend la clé médiane.
+# Les B-arbres: suppression
+## Cas non-feuille!
+![Suppression de 8.](figs/barbres_ordre2_supp9.svg){width=60%}
+. . .
+* On sait comment effacer une valeur d'une feuille, donc?
+. . .
+![Échanger le `8` avec le plus grand du sous-arbre de gauche.](figs/barbres_ordre2_supp10.svg){width=60%}
+* Ensuite?
+# Les B-arbres: suppression
+## Cas non-feuille!
+![Suppression de 8.](figs/barbres_ordre2_supp10.svg){width=60%}
+. . .
+* On sait comment effacer une valeur d'une feuille!
+. . .
+![Yaka enlever le 8 de la feuille comme avant!](figs/barbres_ordre2_supp11.svg){width=60%}
+# Les B-arbres: suppression
+## Algorithme pour les non-feuilles!
+* Si la clé est supprimée d'une page qui n'est pas une feuille:
+    * On échange la valeur avec la valeur de droite de la page de gauche.
+    * On supprime comme pour une feuille!
+## Et maintenant des exercices par millions!
--- a/slides/cours_23.md
+++ b/slides/cours_23.md
+---
+title: "Théorie des graphes"
+date: "2025-05-16"
+---
+# Les graphes
+\Huge
+Les graphes
+# Les graphes! Historique
+**Un mini-peu d'histoire...**
+## L. Euler et les 7 ponts de Koenigsberg:
+* Existe-t-il une promenade sympa, passant **une seule fois** par les 7 ponts et revenant au point de départ?
+![Les ponts, c'est beau. Source: Wikipédia, <https://bit.ly/37h0yOG>](figs/Konigsberg_bridges.png){width=40%}
+. . .
+* Réponse: ben non!
+# Utilisation quotidienne
+## Réseau social
+![Source: Wikipedia, <https://bit.ly/3kG6cgo>](figs/Social_Network.svg){width=40%}
+* Chaque sommet est un individu.
+* Chaque trait une relation d'amitié.
+* Miam, Miam, Facebook.
+# Utilisation quotidienne
+## Moteurs de recherche
+![Source: Wikipedia, <https://bit.ly/3kG6cgo>](figs/PageRanks-Example.svg){width=40%}
+* Site est un sommet.
+* Liens sortants.
+* Liens entrants.
+* Notion d'importance d'un site: combien de liens entrants, pondérés par l'importance du site.
+* Miam, Miam, Google (PageRank).
+# Introduction
+## Définition, plus ou moins
+* Un graphe est un ensemble de sommets, reliés par des lignes ou des flèches.
+![Deux exemples de graphes.](figs/ex_graphes.png)
+* Des sommets (numérotés 1 à 6);
+* Connectés ou pas par des traits ou des flèches!
+# Généralités
+## Définitions
+* Un **graphe** $G(V, E)$ est constitué
+    * $V$: un ensemble de sommets;
+    * $E$: un ensemble d'arêtes.
+* Une **arête** relie une **paire** de sommets de $V$.
+## Remarques
+* Il y a **au plus** une arête $E$ par paire de sommets de $V$.
+* La **complexité** d'un algorithme dans un graphe se mesure en terme de $|E|$ et $|V|$, le nombre d'éléments de $E$ et $V$ respectivement.
+# Généralités
+## Notations
+* Une arête d'un graphe **non-orienté** est représentée par une paire **non-ordonnée** $(u,v)=(v,u)$, avec $u,v\in V$.
+* Les arêtes ne sont pas orientées dans un graphe non-orienté 
+(elles sont bi-directionnelles, c.-à-d. peuvent être parcourues dans n'importe quel sens).
+## Exemple
+::: columns
+:::: column
+![Un graphe non-orienté.](figs/ex_graphe_non_oriente.svg)
+::::
+:::: column
+## Que valent $V$, $|V|$, $E$, et $|E|$?
+. . .
+\begin{align*}
+V&=\{1, 2, 3, 4\},\\
+|V|&=4,\\
+E&=\{(1,2),(2,3),(2,4),(4,1)\},\\
+|E|&=4.
+\end{align*}
+::::
+:::
+# Généralités
+## Notations
+* Une arête d'un graphe **orienté** est représentée par une paire **ordonnée** $(u,v)\neq(v,u)$, avec $u,v\in V$.
+* Les arêtes sont orientées dans un graphe orienté (étonnant non?).
+## Exemple
+::: columns
+:::: column
+![Un graphe orienté.](figs/ex_graphe_oriente.svg)
+::::
+:::: column
+## Que valent $V$, $|V|$, $E$, et $|E|$?
+. . .
+\begin{align*}
+V&=\{1, 2, 3, 4\},\\
+|V|&=4,\\
+E&=\{(1,2),(2,3),(2,4),(4,1),(4,2)\},\\
+|E|&=5.
+\end{align*}
+::::
+:::
+# Généralités
+## Définition
+* Le somme $v$ est **adjacent** au sommet $u$, si et seulement si $(u,v)\in E$;
+* Si un graphe non-orienté contient une arête $(u,v)$, $v$ est adjacent à $u$ et $u$ est adjacent à $v$.
+## Exemple
+::: columns
+:::: column
+![Sommet $a$  adjacent à $c$, $c$ adjacent à $a$.](figs/ex_adj_non_or.svg){width=60%}
+::::
+:::: column
+![Sommet $c$  adjacent à $a$.](figs/ex_adj_or.svg){width=60%}
+::::
+:::
+# Généralités
+## Définition
+* Un **graphe pondéré** ou **valué** est un graphe dont chaque arête a un
+  poids associé, habituellement donné par une fonction de pondération $w:E\rightarrow\mathbb{R}$.
+## Exemples
+![Graphe pondéré orienté (gauche) et non-orienté (droite).](figs/ex_graph_pond.pdf){width=80%}
+# Généralités
+## Définition
+* Dans un graphe $G(V,E)$, une **chaîne** reliant un sommet $u$ à un sommet $v$ est une suite d'arêtes entre les sommets, $w_0$, $w_1$, ..., $w_k$, telles que 
+$$
+(w_i, w_{i+1})\in E,\quad u=w_0,\quad v=w_k,\quad \mbox{pour }0\leq i< k,
+$$
+avec $k$ la longueur de la chaîne (le nombre d'arêtes du chemin).
+## Exemples
+![Illustration d'une chaîne dans un graphe.](figs/ex_graphe_chaine.pdf){width=80%}
+# Généralités
+## Définition
+* Une **chaîne élémentaire** est une chaîne dont tous les sommets sont distincts, sauf les extrémités qui peuvent être égales.
+## Exemples
+![Illustration d'une chaîne élémentaire dans un graphe.](figs/ex_graphe_chaine_elem.pdf){width=80%}
+# Généralités
+## Définition
+* Une **boucle** est une arête $(v,v)$ d'un sommet vers lui-même.
+## Exemples
+![Illustration d'une boucle dans un graphe.](figs/ex_graphe_boucle.pdf){width=40%}
+# Généralités
+## Définition
+* Un graphe non-orienté est dit **connexe**, s'il existe un chemin reliant n'importe quelle paire de sommets distincts.
+## Exemples
+\
+::: columns
+:::: column
+![Graphe connexe. Source: Wikipédia, <https://bit.ly/3yiUzUv>](figs/graphe_connexe.svg){width=60%}
+::::
+:::: column
+![Graphe non-connexe avec composantes connexes. Source: Wikipédia, <https://bit.ly/3KJB76d>](figs/composantes_connexes.svg){width=40%}
+::::
+:::
+# Généralités
+## Définition
+* Un graphe orienté est dit **fortement connexe**, s'il existe un chemin reliant n'importe quelle paire de sommets distincts.
+## Exemples
+\
+::: columns
+:::: column
+![Graphe fortement connexe.](figs/ex_graph_fort_connexe.pdf){width=60%}
+::::
+:::: column
+![Composantes fortement connexes. Source, Wikipédia: <https://bit.ly/3w5PL2l>](figs/composantes_fortement_connexes.svg){width=100%}
+::::
+:::
+# Généralités
+## Définition
+* Un **cycle** dans un graphe *non-orienté* est une chaîne de longueur $\geq 3$ telle que le 1er sommet de la chaîne est le même que le dernier, et dont les arêtes sont distinctes.
+* Pour un graphe *orienté*, on parle de **circuit**.
+* Un graphe sans cycles est dit **acyclique**.
+## Exemples
+![Illustration de cycles.](figs/ex_graphe_cycle.pdf){width=100%}
+# Question de la mort
+* Qu'est-ce qu'un graphe connexe acyclique?
+. . .
+* Un arbre!
+# Représentations
+* La complexité des algorithmes sur les graphes s'expriment en fonction du nombre de sommets $V$, et du nombre d'arêtes $E$:
+    * Si $|E|\sim |V|^2$, on dit que le graphe est **dense**.
+    * Si $|E|\sim |V|$, on dit que le graphe est **peu dense**.
+* Selon qu'on considère des graphes denses ou peu denses, différentes structures de données peuvent être envisagées.
+## Question
+* Comment peut-on représenter un graphe informatiquement? Des idées (réflexion de quelques minutes)?
+. . .
+* Matrice/liste d'adjacence.
+# Matrice d'adjacence
+* Soit le graphe $G(V,E)$, avec $V=\{1, 2, 3, ..., n\}$;
+* On peut représenter un graphe par une **matrice d'adjacence**, $A$, de dimension $n\times n$ définie par
+$$
+A_{ij}=\left\{ \begin{array}{ll}
+         1 & \mbox{si } i,j\in E,\\
+         0 & \mbox{sinon}.
+         \end{array} \right.
+$$
+::: columns
+:::: column
+## Exemple
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    1---2;
+    1---4;
+    2---5;
+    4---5;
+    5---3;
+```
+::::
+:::: column
+\footnotesize
+## Quelle matrice d'adjacence? 
+. . .
+```
+   || 1 | 2 | 3 | 4 | 5
+===||===|===|===|===|===
+ 1 || 0 | 1 | 0 | 1 | 0
+---||---|---|---|---|---
+ 2 || 1 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 3 || 0 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 4 || 1 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 5 || 0 | 1 | 1 | 1 | 0
+```
+::::
+:::
+# Matrice d'adjacence
+## Remarques
+* Zéro sur la diagonale.
+* La matrice d'un graphe non-orienté est symétrique
+$$
+A_{ij}=A_{ji}, \forall i,j\in[1,n]
+$$.
+::: columns
+:::: column
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    1---2;
+    1---4;
+    2---5;
+    4---5;
+    5---3;
+```
+::::
+:::: column
+\footnotesize
+```
+   || 1 | 2 | 3 | 4 | 5
+===||===|===|===|===|===
+ 1 || 0 | 1 | 0 | 1 | 0
+---||---|---|---|---|---
+ 2 || 1 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 3 || 0 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 4 || 1 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 5 || 0 | 1 | 1 | 1 | 0
+```
+::::
+:::
+# Matrice d'adjacence
+* Pour un graphe orienté (digraphe)
+::: columns
+:::: column
+## Exemple
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    2-->1;
+    1-->4;
+    2-->5;
+    5-->2;
+    4-->5;
+    5-->3;
+```
+::::
+:::: column
+\footnotesize
+## Quelle matrice d'adjacence? 
+. . .
+```
+   || 1 | 2 | 3 | 4 | 5
+===||===|===|===|===|===
+ 1 || 0 | 0 | 0 | 1 | 0
+---||---|---|---|---|---
+ 2 || 1 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 3 || 0 | 0 | 0 | 0 | 0
+---||---|---|---|---|---
+ 4 || 0 | 0 | 0 | 0 | 1
+---||---|---|---|---|---
+ 5 || 0 | 1 | 1 | 0 | 0
+```
+::::
+:::
+* La matrice d'adjacence n'est plus forcément symétrique
+$$
+A_{ij}\neq A_{ji}.
+$$
+# Stockage
+* Quel est l'espace nécessaire pour stocker une matrice d'adjacence pour un graphe orienté?
+. . .
+* $\mathcal{O}(|V|^2)$
+* Quel est l'espace nécessaire pour stocker une matrice d'adjacence pour un graphe non-orienté?
+. . .
+* $\mathcal{O}\left((|V|-1)|V|/2\right)$.
+# Considérations d'efficacité
+* Dans quel type de graphes la matrice d'adjacence est-elle utile?
+. . .
+* Dans les graphes denses.
+* Pourquoi?
+. . .
+* Dans les graphes peu denses, la matrice d'adjacence est essentiellement composée de `0`.
+## Remarque
+* Dans la majorité des cas, les grands graphes sont peu denses.
+* Comment représenter un graphe autrement?
+# La liste d'adjacence (non-orienté)
+* Pour chaque sommet $v\in V$, stocker les sommets adjacents à $v$.
+* Quelle structure de données pour la liste d'adjacence?
+. . .
+* Tableau de liste chaînée, vecteur (tableau dynamique), etc.
+::: columns
+:::: column
+## Exemple
+![Un graphe non-orienté.](figs/ex_graph_adj.pdf){width=80%}
+::::
+:::: column
+## Quelle liste d'adjacence? 
+. . .
+![La liste d'adjacence.](figs/ex_graph_list_adj.pdf)
+::::
+:::
+# La liste d'adjacence (orienté)
+::: columns
+:::: column
+## Quelle liste d'adjacence pour...
+* Matrix (2min)
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    0-->1;
+    0-->2;
+    1-->2;
+    3-->0;
+    3-->1;
+    3-->2;
+```
+::::
+:::: column
+```
+```
+::::
+:::
+# Complexité
+## Stockage
+* Quelle espace est nécessaire pour stocker une liste d'adjacence (en fonction de $|E|$ et $|V|$)?
+. . .
+$$
+\mathcal{O}(|V|+|E|)
+$$
+* Pour les graphes *non-orientés*: $\mathcal{O}(|V|+2|E|)$.
+* Pour les graphes *orientés*: $\mathcal{O}(|V|+|E|)$.
+## Définition
+* Le **degré** d'un sommet $v$, est le nombre d'arêtes incidentes du sommet (pour les graphes orientés on a un degré entrant ou sortant).
+* Comment retrouve-t-on le degré de chaque sommet avec la liste d'adjacence?
+. . .
+* C'est la longueur de la liste chaînée si le graphe est non-orienté.
+# Parcours
+* Beaucoup d'applications nécessitent de parcourir des graphes:
+    * trouver un chemin d'un sommet à un autre;
+    * trouver si le graphe est connexe.
+* Il existe *deux* parcours principaux:
+    * en largeur (Breadth-First Search);
+    * en profondeur (Depth-First Search).
+* Ces parcours créent *un arbre* au fil de l'exploration (si le graphe est non-connexe, cela crée une *forêt*, c.-à-d. un ensemble d'arbres).
+# Illustration: parcours en largeur
+![Le parcours en largeur.](figs/parcours_larg.pdf){width=80%}
+# Exemple
+## Étape par étape (blanc non-visité)
+![Initialisation.](figs/parcours_larg_0.pdf){width=50%}
+## Étape par étape (gris visité)
+![On commence en `x`.](figs/parcours_larg_1.pdf){width=50%}
+# Exemple
+## Étape par étape
+![On commence en `x`.](figs/parcours_larg_1.pdf){width=50%}
+## Étape par étape (vert à visiter)
+![Visiter `w`, `t`, `y`.](figs/parcours_larg_2.pdf){width=50%}
+# Exemple
+## Étape par étape
+![Visiter `w`, `t`, `y`.](figs/parcours_larg_2.pdf){width=50%}
+## Étape par étape
+![`w`, `t`, `y` visités. `u`, `s` à visiter.](figs/parcours_larg_3.pdf){width=50%}
+# Exemple
+## Étape par étape
+![`w`, `t`, `y` visités. `u`, `s` à visiter.](figs/parcours_larg_3.pdf){width=50%}
+## Étape par étape
+![`u`, `s`, visités. `r` à visiter.](figs/parcours_larg_4.pdf){width=50%}
+# Exemple
+## Étape par étape
+![`u`, `s`, visités. `r` à visiter.](figs/parcours_larg_4.pdf){width=50%}
+## Étape par étape
+![`r` visité. `v` à visiter.](figs/parcours_larg_5.pdf){width=50%}
+# Exemple
+## Étape par étape
+![`r` visité. `v` à visiter.](figs/parcours_larg_5.pdf){width=50%}
+## Étape par étape
+![The end. Plus rien à visiter!](figs/parcours_larg_6.pdf){width=50%}
+# En faisant ce parcours...
+::: columns
+:::: column
+## Du parcours de l'arbre
+![](figs/parcours_larg_6.pdf){width=100%}
+::::
+:::: column
+## Quel arbre est créé par le parcours (2min)?
+. . .
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    0[x]-->1[w];
+    0-->2[t];
+    0-->3[y];
+    2-->9[u];
+    1-->4[s];
+    4-->5[r];
+    5-->6[v];
+```
+::::
+:::
+## Remarques
+* Le parcours dépend du point de départ dans le graphe.
+* L'arbre sera différent en fonction du noeud de départ, et de l'ordre de parcours des voisins d'un noeud.
+# Le parcours en largeur
+## L'algorithme, idée générale (3min, matrix)?
+. . .
+```C
+v = un sommet du graphe
+i = 1
+pour sommet dans graphe et sommet non-visité
+    visiter(v, sommet, i) // marquer sommet à distance i visité 
+    i += 1
+```
+## Remarque
+* `i` est la distance de plus court chemin entre `v` et les sommets en cours de visite.
+# Le parcours en largeur
+## L'algorithme, pseudo-code (3min, matrix)?
+* Comment garder la trace de la distance?
+. . .
+* Utilisation d'une **file d'attente**
+. . .
+```C
+initialiser(graphe) // tous les sommets sont non-visités
+visiter(sommet, file) // on choisit un sommet de départ 
+tant que !est_vide(file)
+    défiler(file, (v,u))
+    si u != visité
+        ajouter (v,u) à arbre T
+        visiter(u, file)
+```
+## Que fait visiter?
+```
+rien visiter(x, file)
+    marquer x comme visité
+    pour chaque arête (x,w)
+        si w != visité
+            enfiler(file, (x,w))
+```
+# Exercice (5min)
+## Appliquer l'algorithme sur le graphe
+![](figs/parcours_larg_0.pdf){width=50%}
+* En partant de `v`, `s`, ou `u` (par colonne de classe).
+* Bien mettre à chaque étape l'état de la file.
+# Complexité du parcours en largeur
+## Étape 1
+* Extraire un sommet de la file.
+## Étape 2
+* Traîter tous les sommets adjacents.
+## Quelle est la complexité?
+. . .
+* Étape 1: $\mathcal{O}(|V|)$
+* Étape 2: $\mathcal{O}(2|E|)$
+* Total: $\mathcal{O}(|V| + |2|E|)$
+# Exercice
+* Établir la liste d'adjacence et appliquer l'algorithme de parcours en largeur au graphe
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    1---2;
+    1---3;
+    1---4;
+    2---3;
+    2---6;
+    3---6;
+    3---4;
+    3---5;
+    4---5;
+```
+# Illustration: parcours en profondeur
+![Le parcours en profondeur. À quel parcours d'arbre cela ressemble-t-il?](figs/parcours_prof.pdf){width=80%}
+# Parcours en profondeur
+## Idée générale
+* Initialiser les sommets comme non-lus
+* Visiter un sommet
+* Pour chaque sommet visité, on visite un sommet adjacent s'il n'est pas encore visité, et ce récursivement.
+## Remarque
+* La récursivité est équivalent à l'utilisation d'une **pile**.
+# Parcours en profondeur
+## Pseudo-code (5min)
+. . .
+```C
+initialiser(graphe) // tous les sommets sont non-visités
+visiter(sommet, pile) // on choisit un sommet du graphe
+tant que !est_vide(pile)
+    dépiler(pile, (v,u))
+    si u != visité
+        ajouter (v,u) à arbre T
+        visiter(u, pile)
+```
+## Que fait visiter?
+. . .
+```C
+rien visiter(x, pile)
+    marquer x comme visité
+    pour chaque arête (x,w)
+        si w != visité
+            empiler(pile, (x,w))
+```
+# Exercice
+* Établir la liste d'adjacence et appliquer l'algorithme de parcours en profondeur au graphe
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    1---2;
+    1---3;
+    1---4;
+    2---3;
+    2---6;
+    3---6;
+    3---4;
+    3---5;
+    4---5;
+```
+# Interprétation des parcours
+* Un graphe vu comme espace d'états (sommet: état, arête: action)
+    * Labyrinthe
+    * Arbre des coups d'un jeu
+. . .
+* BFS (Breadth-First Search) ou DFS (Depth-First Search) parcourent l'espace des états à la recherche du meilleur mouvement.
+    * Les deux parcourent *tout* l'espace;
+    * Mais si l'arbre est grand, l'espace est gigantesque!
+. . .
+* Quand on a un temps limité
+    * BFS explore beaucoup de coups dans un futur proche;
+    * DFS explore peu de coups dans un futur lointain.
--- a/slides/cours_24.md
+++ b/slides/cours_24.md
+---
+title: "Théorie des graphes et plus courts chemins"
+date: "2025-05-26"
+---
+# Les graphes
+\Huge
+Les graphes
+# Exercice
+* Établir la liste d'adjacence et appliquer l'algorithme de parcours en largeur au graphe
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    1---2;
+    1---3;
+    1---4;
+    2---3;
+    2---6;
+    3---6;
+    3---4;
+    3---5;
+    4---5;
+```
+# Illustration: parcours en profondeur
+![Le parcours en profondeur. À quel parcours d'arbre cela ressemble-t-il?](figs/parcours_prof.pdf){width=80%}
+# Parcours en profondeur
+## Idée générale
+* Initialiser les sommets comme non-lus
+* Visiter un sommet
+* Pour chaque sommet visité, on visite un sommet adjacent s'il n'est pas encore visité, et ce récursivement.
+## Remarque
+* La récursivité est équivalente à l'utilisation d'une **pile**.
+# Parcours en profondeur
+## Pseudo-code (5min)
+. . .
+```C
+initialiser(graphe) // tous les sommets sont non-visités
+visiter(sommet, pile) // on choisit un sommet du graphe
+tant que !est_vide(pile)
+    dépiler(pile, (v,u))
+    si u != visité
+        ajouter (v,u) à arbre T
+        visiter(u, pile)
+```
+## Que fait visiter?
+. . .
+```C
+rien visiter(x, pile)
+    marquer x comme visité
+    pour chaque arête (x,w)
+        si w != visité
+            empiler(pile, (x,w))
+```
+# Exercice
+* Établir la liste d'adjacence et appliquer l'algorithme de parcours en profondeur au graphe
+```{.mermaid format=pdf width=400 loc=figs/}
+graph LR;
+    1---2;
+    1---3;
+    1---4;
+    2---3;
+    2---6;
+    3---6;
+    3---4;
+    3---5;
+    4---5;
+```
+# Interprétation des parcours
+* Un graphe vu comme espace d'états (sommet: état, arête: action);
+    * Labyrinthe;
+    * Arbre des coups d'un jeu.
+. . .
+* BFS (Breadth-First) ou DFS (Depth-First) parcourent l'espace des états à la recherche du meilleur mouvement.
+    * Les deux parcourent *tout* l'espace;
+    * Mais si l'arbre est grand, l'espace est gigantesque!
+. . .
+* Quand on a un temps limité
+    * BFS explore beaucoup de coups dans un futur proche;
+    * DFS explore peu de coups dans un futur lointain.
+# Algorithmes de plus courts chemins
+\Huge Plus courts chemins
+# Contexte: les réseaux (informatique, transport, etc.)
+* Graphe orienté;
+* Source: sommet `s`;
+* Destination: sommet `t`;
+* Les arêtes ont des poids (coût d'utilisation, distance, etc.);
+* Le coût d'un chemin est la somme des poids des arêtes d'un chemin.
+## Problème à résoudre
+* Quel est le plus court chemin entre `s` et `t`?
+# Exemples d'application de plus courts chemins
+## Devenir riches!
+* On part d'un tableau de taux de change entre devises.
+* Quelle est la meilleure façon de convertir l'or en dollar?
+![Taux de change.](figs/taux_change.pdf){width=80%}
+. . .
+* 1kg d'or => 327.25 dollars
+* 1kg d'or => 208.1 livres => 327 dollars
+* 1kg d'or => 455.2 francs => 304.39 euros => 327.28 dollars
+# Exemples d'application de plus courts chemins
+## Formulation sous forme d'un graphe: Comment (3min)?
+![Taux de change.](figs/taux_change.pdf){width=80%}
+# Exemples d'application de plus courts chemins
+## Formulation sous forme d'un graphe: Comment (3min)?
+![Graphes des taux de change.](figs/taux_change_graphe.pdf){width=60%}
+* Un sommet par devise;
+* Une arête orientée par transaction possible avec le poids égal au taux de change;
+* Trouver le chemin qui maximise le produit des poids.
+. . .
+## Problème
+* On aimerait plutôt avoir une somme...
+# Exemples d'application de plus courts chemins
+## Conversion du problème en plus courts chemins
+* Soit `taux(u, v)` le taux de change entre la devise `u` et `v`.
+* On pose `w(u,w)=-log(taux(u,v))`
+* Trouver le chemin poids minimal pour les poids `w`.
+![Graphe des taux de change avec logs.](figs/taux_change_graphe_log.pdf){width=60%}
+* Cette conversion se base sur l'idée que
+$$
+\log(u\cdot v)=\log(u)+\log(v).
+$$
+# Applications de plus courts chemins
+## Quelles applications voyez-vous?
+. . .
+* Déplacement d'un robot;
+* Planificaiton de trajet / trafic urbain;
+* Routage de télécommunications;
+* Réseau électrique optimal;
+* ...
+# Algorithmes de plus courts chemins
+\Huge
+Algorithmes de plus courts chemins
+# Rappel de la problématique
+* Graphe orienté;
+* Source: sommet `s`;
+* Destination: sommet `t`;
+* Les arêtes ont des poids (coût d'utilisation, distance, etc.);
+* Le coût d'un chemin est la somme des poids des arêtes d'un chemin.
+## Problème à résoudre
+* Quel est le plus court chemin entre `s` et `t`.
+# Plus courts chemins à source unique
+* Soit un graphe, $G=(V, E)$, une fonction de pondération $w:E\rightarrow\mathbb{R}$, et un sommet $s\in V$
+  * Trouver pour tout sommet $v\in V$, le chemin de poids minimal reliant $s$ à $v$.
+* Algorithmes standards:
+  * Dijkstra (arêtes de poids positif seulement);
+  * Bellman-Ford (arêtes de poids positifs ou négatifs, mais sans cycles négatifs).
+* Comment résoudre le problèmes si tous les poids sont les mêmes?
+. . .
+* Un parcours en largeur!
+# Algorithme de Dijkstra
+## Comment chercher pour un plus court chemin?
+. . .
+```
+si distance(u,v) > distance(u,w) + distance(w,v)
+    on passe par w plutôt qu'aller directement
+```
+# Algorithme de Dijkstra (1 à 5)
+* $D$ est le tableau des distances au sommet $1$: $D[7]$ est la distance de 1 à 7.
+* Le chemin est pas forcément direct.
+* $S$ est le tableau des sommets visités.
+::: columns
+:::: column
+![Initialisation.](figs/dijkstra_0.png)
+::::
+:::: column
+. . .
+![1 visité, `D[2]=1`, `D[4]=3`.](figs/dijkstra_1.png)
+::::
+:::
+# Algorithme de Dijkstra (1 à 5)
+::: columns
+:::: column
+![Plus court est 2.](figs/dijkstra_1.png)
+::::
+:::: column
+. . .
+![2 visité, `D[3]=2`, `D[7]=3`.](figs/dijkstra_2.png)
+::::
+:::
+# Algorithme de Dijkstra (1 à 5)
+::: columns
+:::: column
+![Plus court est 3.](figs/dijkstra_2.png)
+::::
+:::: column
+. . .
+![3 visité, `D[7]=3` inchangé, `D[6]=6`.](figs/dijkstra_3.png)
+::::
+:::
+# Algorithme de Dijkstra (1 à 5)
+::: columns
+:::: column
+![Plus court est 4 ou 7.](figs/dijkstra_3.png)
+::::
+:::: column
+. . .
+![4 visité, `D[7]=3` inchangé, `D[5]=9`.](figs/dijkstra_4.png)
+::::
+:::
+# Algorithme de Dijkstra (1 à 5)
+::: columns
+:::: column
+![Plus court est `7`.](figs/dijkstra_4.png)
+::::
+:::: column
+. . .
+![7 visité, `D[5]=7`, `D[6]=6` inchangé.](figs/dijkstra_5.png)
+::::
+:::
+# Algorithme de Dijkstra (1 à 5)
+::: columns
+:::: column
+![Plus court est 6.](figs/dijkstra_5.png)
+::::
+:::: column
+. . .
+![`6` visité, `D[5]=7` inchangé.](figs/dijkstra_6.png)
+::::
+:::
+# Algorithme de Dijkstra (1 à 5)
+::: columns
+:::: column
+![Plus court est 5 et c'est la cible.](figs/dijkstra_6.png)
+::::
+:::: column
+. . .
+![The end, tous les sommets ont été visités.](figs/dijkstra_7.png)
+::::
+:::
+# Algorithme de Dijkstra
+## Idée générale
+* On assigne à chaque noeud une distance $0$ pour $s$, $\infty$ pour les autres.
+* Tous les noeuds sont marqués non-visités.
+* Depuis le noeud courant, on suit chaque arête du noeud vers un sommet non visité et on calcule le poids du chemin à chaque voisin et on met à jour sa distance si elle est plus petite que la distance du noeud.
+* Quand tous les voisins du noeud courant ont été visités, le noeud est mis à visité (il ne sera plus jamais visité).
+* Continuer avec le noeud à la distance la plus faible.
+* L'algorithme est terminé losrque le noeud de destination est marqué comme visité, ou qu'on n'a plus de noeuds qu'on peut visiter et que leur distance est infinie.
+# Algorithme de Dijkstra
+## Pseudo-code (5min, matrix)
+\footnotesize
+. . .
+```C
+tab dijkstra(graph, s, t)
+    pour chaque v dans graphe
+        distance[v] = infini
+    distance[s] = 0
+    q = ajouter(q, s) // q est une liste
+    tant que non_vide(q)
+    // sélection de u t.q. la distance dans q est min
+        u = min(q, distance)
+        si u == t // on a atteint la cible
+            retourne distance
+        q = remove(q, u)
+        // voisin de u encore dans q
+        pour chaque v dans voisinage(u, q)
+        // on met à jour la distance du voisin en passant par u 
+            n_distance = distance[u] + w(u, v)
+            si n_distance < distance[v]
+                distance[v] = n_distance
+    retourne distance
+```
+# Algorithme de Dijkstra
+* Cet algorithme, nous donne le plus court chemin mais...
+* ne nous donne pas le chemin!
+## Comment modifier l'algorithme pour avoir le chemin?
+. . .
+* Pour chaque nouveau noeud à visiter, il suffit d'enregistrer d'où on est venu!
+* On a besoin d'un tableau `precedent`.
+## Modifier le pseudo-code ci-dessus pour ce faire (3min matrix)
+# Algorithme de Dijkstra
+\footnotesize
+```C
+tab, tab dijkstra(graph, s, t)
+    pour chaque v dans graphe
+        distance[v] = infini
+        precedent[v] = indéfini     
+    distance[s] = 0
+    q = ajouter(q, s)
+    tant que non_vide(q)
+    // sélection de u t.q. la distance dans q est min
+        u = min(q, distance) 
+        si u == t
+            retourne distance, precedent
+        q = remove(q, u)
+        // voisin de u encore dans q
+        pour chaque v dans voisinage(u, q) 
+            n_distance = distance[u] + w(u, v)
+            si n_distance < distance[v]
+                distance[v] = n_distance
+                precedent[v] = u
+    retourne distance, precedent
+```
+# Algorithme de Dijkstra
+## Comment reconstruire un chemin ?
+. . .
+```C
+pile parcours(precedent, s, t)
+    sommets = vide
+    u = t
+    // on a atteint t ou on ne connait pas de chemin
+    si u != s && precedent[u] != indéfini 
+        tant que vrai 
+            sommets = empiler(sommets, u)
+            u = precedent[u]
+            si u == s // la source est atteinte
+                retourne sommets
+    retourne sommets
+```
+# Algorithme de Dijkstra amélioré
+## On peut améliorer l'algorithme
+* Avec une file de priorité!
+## Une file de priorité est
+* Une file dont chaque élément possède une priorité,
+* Elle existe en deux saveurs: `min` ou `max`:
+    * File `min`: les éléments les plus petits sont retirés en premier.
+    * File `max`: les éléments les plus grands sont retirés en premier.
+* On regarde l'implémentation de la `max`.
+## Comment on fait ça?
+. . .
+* On insère les éléments à haute priorité tout devant dans la file!
+# Les files de priorité
+## Trois fonction principales
+```C
+booléen est_vide(element) // triviale
+element enfiler(element, data, priorite)
+data defiler(element)
+rien changer_priorite(element, data, priorite)
+nombre priorite(element) // utilitaire
+```
+## Pseudo-implémentation: structure (1min)
+. . .
+```C
+struct element
+    data
+    priorite
+    element suivant
+```
+# Les files de priorité
+## Pseudo-implémentation: enfiler (2min)
+. . .
+```C
+element enfiler(element, data, priorite)
+    n_element = creer_element(data, priorite)
+    si est_vide(element)
+        retourne n_element
+    si priorite(n_element) > priorite(element)
+        n_element.suivant = element
+        retourne n_element
+    sinon
+        tmp = element
+        prec = element
+        tant que !est_vide(tmp) 
+                 && priorite(n_element) < priorite(tmp)
+            prec = tmp
+            tmp = tmp.suivant
+        prec.suivant = n_element
+        n_element.suivant = tmp
+        retourne element           
+```
+# Les files de priorité
+## Pseudo-implémentation: defiler (2min)
+. . .
+```C
+data, element defiler(element)
+    si est_vide(element)
+        retourne AARGL!
+    sinon
+        tmp = element.data
+        n_element = element.suivant
+        liberer(element)
+        retourne tmp, n_element
+```
+# Algorithme de Dijkstra avec file de priorité min
+```C
+distance, precedent dijkstra(graphe, s, t):
+    fp = file_p_vide()
+    distance[s] = 0
+    pour v dans sommets(graphe)
+        si v != s
+            distance[v] = infini
+        precedent[v] = indéfini
+        fp = enfiler(fp, v, distance[v])
+    tant que !est_vide(fp)
+        u, fp = defiler(fp)
+        si u == t
+            retourne distance, precedent
+        pour v dans voisinage de u
+            n_distance = distance[u] + w(u, v)
+            si n_distance < distance[v]
+                distance[v] = n_distance
+                precedent[v] = u
+                fp = changer_priorite(fp, v, n_distance)
+    retourne distance, precedent
+```
+# Algorithme de Dijkstra avec file
+\footnotesize
+```C
+distance dijkstra(graphe, s, t)
+--------------------O(V*V)--------------------------------
+    distance[s] = 0
+    fp = file_p_vide()
+    pour v dans sommets(graphe) // O(|V|)
+        si v != s
+            distance[v] = infini
+        fp = enfiler(fp, s, distance[s]) // O(|V|)
+------------------O(V * V)-------------------------------
+    tant que !est_vide(fp)
+        u, fp = defiler(fp) // O(1)
+---------------------------------------------------------
+        pour v dans voisinage de u // O(|E|)
+            n_distance = distance[u] + w(u, v)
+            si n_distance < distance[v]
+                distance[v] = n_distance
+                fp = changer_priorite(fp, v, n_distance) // O(|V|)
+---------------------------------------------------------
+    retourne distance
+```
+* Total: $\mathcal{O}(|V|^2+|E|\cdot |V|)$:
+    * Graphe dense: $\mathcal{O}(|V|^3)$ 
+    * Graphe peu dense: $\mathcal{O}(|V|^2)$ 
+# Algorithme de Dijkstra avec file
+## On peut faire mieux
+* Avec une meilleure implémentation de la file de priorité:
+    * Tas binaire: $\mathcal{O}(|V|\log|V|+|E|\log|V|)$.
+    * Tas de Fibonnacci: $\mathcal{O}(|V|+|E|\log|V|)$
+* Graphe dense: $\mathcal{O}(|V|^2\log|V|)$.
+* Graphe peu dense: $\mathcal{O}(|V|\log|V|)$.
+# Algorithme de Dijkstra (exercice, 5min) 
+![L'exercice.](figs/dijkstra_exo.png){width=60%}
+* Donner la liste de priorité, puis...
+## A chaque étape donner:
+* Le tableau des distances à `a`;
+* Le tableau des prédécesseurs;
+* L'état de la file de priorité.
+# Algorithme de Dijkstra (corrigé) 
+![Le corrigé partie 1.](figs/dijkstra_ex_0.png)
+# Algorithme de Dijkstra (corrigé) 
+![Le corrigé partie 2.](figs/dijkstra_ex_1.png)
+# Algorithme de Dijkstra (corrigé) 
+![Le corrigé partie 3.](figs/dijkstra_ex_2.png)
+# Algorithme de Dijkstra (corrigé) 
+![Le corrigé partie 4.](figs/dijkstra_ex_3.png)
+# Algorithme de Dijkstra (corrigé) 
+![Le corrigé partie 5.](figs/dijkstra_ex_4.png)
+# Algorithme de Dijkstra (corrigé) 
+![Le corrigé partie 6.](figs/dijkstra_ex_5.png)
+# Limitation de l'algorithme de Dijkstra
+## Que se passe-t-il pour?
+![Exemple.](figs/exemple_neg.png){width=50%}
+## Quel est le problème?
+. . .
+* L'algorithme n'essaiera jamais le chemin `s->x->y->v` et prendra direct `s->v`.
+* Ce problème n'apparaît que s'il y a des poids négatifs.
+# Plus cours chemin pour toute paire de sommets
+## Comment faire pour avoir toutes les paires?
+. . .
+* Appliquer Dijkstra sur tous les sommets d'origine.
+* Complexité:
+    * Graphe dense: $\mathcal{O}(|V|)\mathcal{O}(|V|^2\log|V|)=\mathcal{O}(|V|^3\log|V|)$.
+    * Graphe peu dense: $\mathcal{O}(|V|)\mathcal{O}(|V|\log|V|)=\mathcal{O}(|V|^2\log|V|)$.
+. . .
+## Solution alternative: Floyd--Warshall
+* Pour toutes paires de sommets $u,v\in V$, trouver le chemin de poids minimal reliant $u$ à $v$.
+* Complexité $\mathcal{O}(|V|^3)$, indiqué pour graphes denses.
+* Fonctionne avec la matrice d'adjacence.
+# Algorithme de Floyd--Warshall
+## Idée générale
+* Soit l'ensemble de sommets $V=\{1, 2, 3, 4, ..., n\}$.
+* Pour toute paire de sommets, $i,j$, on considère tous les chemins passant par les sommets intermédiaires $\in\{1, 2, ..., k\}$ avec $k\leq n$.
+* On garde pour chaque $k$ la plus petite valeur.
+## Principe
+* A chaque étape, $k$, on vérifie s'il est plus court d'aller de $i$ à $j$ en passant par le sommet $k$.
+* Si à l'étape $k-1$, le coût du parcours est $p$, on vérifie si $p$ est plus petit que $p_1+p_2$, le chemin de $i$ à $k$, et $k$ à $j$ respectivement.
+# Algorithme de Floyd--Warshall
+## The algorithme
+Soit $d_{ij}(k)$ le plus court chemin de $i$ à $j$ passant par les sommets $\in\{1,2,...,k\}$
+$$
+d_{ij}(k)=\left\{
+\begin{array}{ll}
+         w(i,j), & \mbox{si } k=0,\\
+         \min(d_{ij}(k-1),d_{ik}(k-1)+d_{kj}(k-1)), & \mbox{sinon}.
+\end{array}
+\right.
+$$
+# Algorithme de Floyd--Warshall (exemple)
+::: columns
+:::: column
+![Le graphe, $D=w$.](figs/floyd_exemple.png)
+::::
+:::: column
+## Que vaut $D^{(0)}$ (3min)?
+. . .
+$$
+D^{(0)}=\begin{bmatrix}
+0      & 2      & 4      & \infty & 3 \\
+2      & 0      & 8      & \infty & 1 \\
+6      & 2      & 0      & 4      & 3 \\
+1      & \infty & \infty & 0      & 5 \\
+\infty & \infty & \infty & 1      & 0 \\
+\end{bmatrix}
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall (exemple)
+::: columns
+:::: column
+## On part de $D^{(0)}$?
+$$
+D^{(0)}=\begin{bmatrix}
+0      & 2      & 4      & \infty & 3 \\
+2      & 0      & 8      & \infty & 1 \\
+6      & 2      & 0      & 4      & 3 \\
+1      & \infty & \infty & 0      & 5 \\
+\infty & \infty & \infty & 1      & 0 \\
+\end{bmatrix}
+$$
+::::
+:::: column
+## Que vaut $D^{(1)}$ (3min)?
+. . .
+$$
+D^{(1)}=\begin{bmatrix}
+0      & 2          & 4               & \infty & 3 \\
+2      & 0          & \mathbf{6}      & \infty & 1 \\
+6      & 2          & 0               & 4      & 3 \\
+1      & \mathbf{3} & \mathbf{5}      & 0      & \mathbf{4} \\
+\infty & \infty     & \infty          & 1      & 0 \\
+\end{bmatrix}
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall (exemple)
+::: columns
+:::: column
+## On part de $D^{(0)}$
+$$
+D^{(0)}=\begin{bmatrix}
+0      & 2      & 4      & \infty & 3 \\
+2      & 0      & 8      & \infty & 1 \\
+6      & 2      & 0      & 4      & 3 \\
+1      & \infty & \infty & 0      & 5 \\
+\infty & \infty & \infty & 1      & 0 \\
+\end{bmatrix}
+$$
+::::
+:::: column
+## Que vaut $D^{(1)}$ (3min)?
+. . .
+$$
+D^{(1)}=\begin{bmatrix}
+0      & 2          & 4               & \infty & 3 \\
+2      & 0          & \mathbf{6}      & \infty & 1 \\
+6      & 2          & 0               & 4      & 3 \\
+1      & \mathbf{3} & \mathbf{5}      & 0      & \mathbf{4} \\
+\infty & \infty     & \infty          & 1      & 0 \\
+\end{bmatrix}
+$$
+## Exemple
+$$
+D_{42}^{(1)}=D_{41}^{(0)}+D_{12}^{(0)}=1+2<\infty.
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall (exemple)
+::: columns
+:::: column
+## On part de $D^{(1)}$
+$$
+D^{(1)}=\begin{bmatrix}
+0      & 2          & 4      & \infty & 3 \\
+2      & 0          & 6      & \infty & 1 \\
+6      & 2          & 0      & 4      & 3 \\
+1      & 3          & 5      & 0      & 4 \\
+\infty & \infty     & \infty & 1      & 0 \\
+\end{bmatrix}
+$$
+::::
+:::: column
+## Que vaut $D^{(2)}$ (3min)?
+. . .
+$$
+D^{(2)}=\begin{bmatrix}
+0          & 2          & 4      & \infty & 3 \\
+2          & 0          & 6      & \infty & 1 \\
+\mathbf{4} & 2          & 0      & 4      & 3 \\
+1          & 3          & 5      & 0      & 4 \\
+\infty     & \infty     & \infty & 1      & 0 \\
+\end{bmatrix}
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall (exemple)
+::: columns
+:::: column
+## On part de $D^{(2)}$
+$$
+D^{(2)}=\begin{bmatrix}
+0          & 2          & 4      & \infty & 3 \\
+2          & 0          & 6      & \infty & 1 \\
+4          & 2          & 0      & 4      & 3 \\
+1          & 3          & 5      & 0      & 4 \\
+\infty     & \infty     & \infty & 1      & 0 \\
+\end{bmatrix}
+$$
+::::
+:::: column
+## Que vaut $D^{(3)}$ (3min)?
+. . .
+$$
+D^{(3)}=\begin{bmatrix}
+0          & 2          & 4      & \mathbf{8}  & 3 \\
+2          & 0          & 6      & \mathbf{10} & 1 \\
+4          & 2          & 0      & 4           & 3 \\
+1          & 3          & 5      & 0           & 4 \\
+\infty     & \infty     & \infty & 1           & 0 \\
+\end{bmatrix}
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall (exemple)
+::: columns
+:::: column
+## On part de $D^{(3)}$
+$$
+D^{(3)}=\begin{bmatrix}
+0          & 2          & 4      & 8  & 3 \\
+2          & 0          & 6      & 10 & 1 \\
+4          & 2          & 0      & 4  & 3 \\
+1          & 3          & 5      & 0  & 4 \\
+\infty     & \infty     & \infty & 1  & 0 \\
+\end{bmatrix}
+$$
+::::
+:::: column
+## Que vaut $D^{(4)}$ (3min)?
+. . .
+$$
+D^{(4)}=\begin{bmatrix}
+0          & 2          & 4         & 8  & 3 \\
+2          & 0          & 6         & 10 & 1 \\
+4          & 2          & 0         & 4  & 3 \\
+1          & 3          & 5         & 0  & 4 \\
+\mathbf{2} & \mathbf{4} & \mathbf{6} & 1  & 0 \\
+\end{bmatrix}
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall (exemple)
+::: columns
+:::: column
+## On part de $D^{(4)}$
+$$
+D^{(4)}=\begin{bmatrix}
+0          & 2          & 4         & 8  & 3 \\
+2          & 0          & 6         & 10 & 1 \\
+4          & 2          & 0         & 4  & 3 \\
+1          & 3          & 5         & 0  & 4 \\
+2          & 4          & 6         & 1  & 0 \\
+\end{bmatrix}
+$$
+::::
+:::: column
+## Que vaut $D^{(5)}$ (3min)?
+. . .
+$$
+D^{(5)}=\begin{bmatrix}
+0          & 2          & 4         & \mathbf{4} & 3 \\
+2          & 0          & 6         & \mathbf{2} & 1 \\
+4          & 2          & 0         & 4          & 3 \\
+1          & 3          & 5         & 0          & 4 \\
+2          & 4          & 6         & 1          & 0 \\
+\end{bmatrix}
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall
+## The pseudo-code (10min)
+* Quelle structure de données?
+* Quelle initialisation?
+* Quel est le code pour le calcul de la matrice $D$?
+# Algorithme de Floyd--Warshall
+## The pseudo-code
+* Quelle structure de données?
+```C
+int distance[n][n];
+```
+. . .
+* Quelle initialisation?
+```C
+matrice ini_floyd_warshall(distance, n, w)
+    pour i de 1 à n
+        pour j de 1 à n
+            distance[i][j] = w(i,j)
+    retourne distance
+```
+# Algorithme de Floyd--Warshall
+## The pseudo-code
+* Quel est le code pour le calcul de la matrice $D$?
+```C
+matrice floyd_warshall(distance, n, w)
+    pour k de 1 à n
+        pour i de 1 à n
+            pour j de 1 à n
+                distance[i][j] = min(distance[i][j], 
+                    distance[i][k] + distance[k][j])
+    retourne distance
+```
+# Algorithme de Floyd--Warshall
+## La matrice de précédence
+* On a pas encore vu comment reconstruire le plus court chemin!
+* On définit, $P_{ij}^{(k)}$, qui est le prédécesseur du sommet $j$ depuis $i$ avec les sommets intermédiaires $\in\{1, 2, ..., k\}$.
+$$
+P^{(0)}_{ij}=\left\{
+\begin{array}{ll}
+         \mbox{vide}, & \mbox{si } i=j\mbox{, ou }w(i,j)=\infty\\
+         i, & \mbox{sinon}.
+\end{array}
+\right.
+$$
+* Mise à jour
+$$
+P^{(k)}_{ij}=\left\{
+\begin{array}{ll}
+         P^{(k-1)}_{\mathbf{i}j}, & \mbox{si } d_{ij}^{(k)}\leq d_{ik}^{(k-1)}+d_{kj}^{(k-1)}\\
+         P^{(k-1)}_{\mathbf{k}j}, & \mbox{sinon}.
+\end{array}
+\right.
+$$
+. . .
+* Moralité: si le chemin est plus court en passant par $k$, alors il faut utiliser son prédécesseur!
+# Algorithme de Floyd--Warshall
+## La matrice de précédence (pseudo-code, 3min)
+. . .
+```C
+matrice, matrice floyd_warshall(distance, n, w)
+    pour k de 1 à n
+        pour i de 1 à n
+            pour j de 1 à n
+                n_distance = distance[i][k] + distance[k][j]
+                if n_distance < distance[i][j]
+                    distance[i][j] = n_distance
+                    précédence[i][j] = précédence[k][j]
+    retourne distance, précédence
+```
+# Algorithme de Floyd--Warshall (exercice)
+::: columns
+:::: column
+![Le graphe, $D=w$.](figs/floyd_exemple.png)
+::::
+:::: column
+## Que vaut $P^{(0)}$ (3min)?
+. . .
+$$
+P^{(0)}=\begin{bmatrix}
+-          & 1          & 1         & -          & 1 \\
+2          & -          & 2         & -          & 2 \\
+3          & 3          & -         & 3          & 3 \\
+4          & -          & -         & -          & 4 \\
+-          & -          & -         & 5          & - \\
+\end{bmatrix}
+$$
+::::
+:::
+# Algorithme de Floyd--Warshall (exercice)
+::: columns
+:::: column
+![Le graphe, $D=w$.](figs/floyd_exemple.png)
+::::
+:::: column
+## Que vaut $P^{(5)}$ (10min)?
+. . .
+$$
+P^{(5)}=\begin{bmatrix}
+-          & 1          & 1         & 5          & 1 \\
+2          & -          & 1         & 5          & 2 \\
+2          & 3          & -         & 3          & 3 \\
+4          & 1          & 1         & -          & 1 \\
+4          & 1          & 1         & 5          & - \\
+\end{bmatrix}
+$$
+::::
+:::
+# Exercice: retrouver le chemin entre 1 et 4 (5min)
+$$
+P=\begin{bmatrix}
+-          & 1          & 1         & 5          & 1 \\
+2          & -          & 1         & 5          & 2 \\
+2          & 3          & -         & 3          & 3 \\
+4          & 1          & 1         & -          & 4 \\
+4          & 1          & 1         & 5          & - \\
+\end{bmatrix}
+$$
+. . .
+## Solution
+* Le sommet $5=P_{14}$, on a donc, $5\rightarrow 4$, on veut connaître le prédécesseur de 5.
+* Le sommet $1=P_{15}$, on a donc, $1\rightarrow 5\rightarrow 4$. The end.
+# Exercice complet
+## Appliquer l'algorithme de Floyd--Warshall au graphe suivant
+![The exorcist.](figs/floyd_exercice.png){width=50%}
+* Bien indiquer l'état de $D$ et $P$ à chaque étape!
+* Ne pas oublier de faire la matrice d'adjacence évidemment...
No results found