README.md

@@ -7,8 +7,11 @@ Merci aux contributeurs suivants pour leurs efforts (dans un ordre alphabétique
 * A. Boyer
 * M. Corboz
 * M. Divià
+* Y. El Hakouni
 * A. Escribano
 * P. Kunzli
 * G. Legouic
 * G. Marino Jarrin
+* H. Radhwan
 * I. Saroukhanian
+* C. Volta

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
+...
+

slides/.gitignore

-*.pdf
-*.err
-*.markdown
-*.html
-index.md
+diagram*.pdf
+cours*.pdf
+intro.pdf
+mermaid-filter.err
 .puppeteer.json

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)

slides/cours_1.md

 ---
-title: "Introduction aux algorithmes"
-date: "2023-09-19"
+title: "Introduction aux algorithmes I"
+date: "2024-09-16"
 ---
 
 # Qu'est-ce qu'un algorithme?

slides/cours_10.md

+---
+title: "Backtracking et piles"
+date: "2024-12-02"
+---
+
+# Le problème des 8-reines
+
+\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à.
+
+. . .
+
+* 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+# 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?
+
+. . .
+
+Une matrice de booléens fera l'affaire:
+
+```C
+bool board[n][n];
+```
+
+## Quelles fonctionnalités?
+
+. . .
+
+```C
+// Pour chaque ligne placer la reine sur toutes les colonnes
+//    et compter les solutions
+void nbr_solutions(board, column, counter);
+// Copier un tableau dans un autre
+void copy(board_in, board_out);
+// Placer la reine à li, co et rendre inaccessible devant
+void placer_devant(board, li, co);
+```
+
+# Le code du problème des 8 reines (2/5)
+
+## 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
+// Placer une reine et mettre à jour
+rien placer_devant(board, ligne, colonne)
+    board est occupé à ligne/colonne
+        toutes les cases des colonnes
+           suivantes sont mises à jour
+```
+
+# Le code du problème des 8 reines (4/5)
+
+## Compris? Alors écrivez le code et postez le!
+
+. . .
+
+## Le nombre de solutions
+
+\footnotesize
+
+```C
+// Calcule le nombre de solutions au problème des <n> reines
+void nb_sol(int n, bool board[n][n], int co, int *ptr_cpt) {
+    for (int li = 0; li < n; li++) {
+        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;
+            }
+        }
+    }
+}
+```
+
+
+# Le code du problème des 8 reines (5/5)
+
+\footnotesize
+
+## Placer devant
+
+```C
+// Retourne une copie du tableau <board> complété avec les positions
+// prises sur la droite droite par une reine placée en <board(li,co)>
+void placer_devant(int n, bool board[n][n], int li, int co) {
+    board[li][co] = false; // position de la reine
+    for (int j = 1; j < n-co; j++) {
+        // 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
+
+# Les piles (1/5)
+
+## Qu'est-ce donc?
+
+* Structure de données abstraite...
+
+. . .
+
+* de type `LIFO` (*Last in first out*).
+
+![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%}
+
+## Des exemples de la vraie vie
+
+. . .
+
+* 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).
+
+# Les piles (2/5)
+
+## 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?).
+
+. . .
+
+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;
+```
+
+# Les piles (4/5)
+
+## Initialisation
+
+. . .
+
+```C
+void stack_init(stack *s) {
+    s->top = -1;
+}
+```
+
+## Est vide?
+
+. . .
+
+```C
+bool stack_is_empty(stack s) {
+    return s.top == -1;
+} 
+```
+
+## Empiler (ajouter un élément au sommet)
+
+. . .
+
+```C
+void stack_push(stack *s, int val) {
+    s->top += 1;
+    s->data[s->top] = val;
+}
+```
+
+# Les piles (5/5)
+
+## Dépiler (enlever l'élément du sommet)
+
+. . .
+
+```C
+int stack_pop(stack *s) {
+    s->top -= 1;
+    return s->data[s->top+1];
+}
+```
+
+## Jeter un oeil (regarder le sommet)
+
+. . .
+
+```C
+int stack_peek(stack s) {
+    return s.data[s.top];
+}
+```
+
+## Quelle est la complexité de ces opérations?
+
+. . .
+
+## Voyez-vous des problèmes potentiels avec cette implémentation?
+
+. . .
+
+* Empiler avec une pile pleine.
+* Dépiler avec une pile vide.
+* Jeter un oeil au sommet d'une pile vide.
+
+# Gestion d'erreur, level 0
+
+* 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.
+
+## La panique
+
+* En C, on a les `assert()` pour faire paniquer un programme.
+
+# Les assertions
+
+\Huge Les assertions
+
+# Assertions (1/3)
+
+```C
+#include <assert.h>
+void assert(int expression);
+```
+
+## Qu'est-ce donc?
+
+- 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`)
+
+## À quoi ça sert?
+
+- 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)
+
+<!-- \footnotesize -->
+
+## Exemple
+
+```C
+#include <assert.h>
+void stack_push(stack *s, int val) {
+    assert(s->top < MAX_CAPACITY-1);
+    s->top += 1;
+    s->data[s->top] = val;
+}
+int stack_pop(stack *s) {
+    assert(s->top >= 0);
+    s->top -= 1;
+    return s->data[s->top+1];
+}
+int stack_peek(stack *s) {
+    assert(s->top >= 0);
+    return s->data[s->top];
+}
+```
+
+# Assertions (3/3)
+
+## Cas typiques d'utilisation
+
+- Vérification de la validité des pointeurs (typiquement `!= NULL`{.C}).
+- Vérification du domaine des indices (dépassement de tableau).
+
+## Bug vs. erreur de *runtime*
+
+- 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.
+
+
+# La pile dynamique
+
+## Comment modifier le code précédent pour avoir une taille dynamique?
+
+. . .
+
+```C
+// alloue une zone mémoire de size octets
+void *malloc(size_t size); 
+// change la taille allouée à size octets (contiguïté garantie)
+void *realloc(void *ptr, size_t size);
+```
+
+. . .
+
+**Attention:** `malloc` sert à allouer un espace mémoire (**pas** de notion de tableau).
+
+## Et maintenant?
+
+. . .
+
+```C
+void stack_create(stack *s); // crée une pile avec une taille par défaut
+// vérifie si la pile est pleine et réalloue si besoin
+void stack_push(stack *s, int val);
+// vérifie si la pile est vide/trop grande 
+// et réalloue si besoin
+void stack_pop(stack *s, int *ret); 
+```
+
+. . .
+
+## Faisons s'implémentation ensemble
+

slides/cours_11.md

+---
+title: "Applications des piles, listes chaînées et files d'attente"
+date: "2024-12-09"
+---
+
+# Rappel: les piles
+
+## 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
+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.
+```
+
+## Exercice: écrire `2 * 3 * 4 + 2` en notation `postfixe`
+
+. . .
+
+```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
+
+```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
+
+## 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) {
+        if (is_operand(infix[i])) { 
+            // we just add operands in the new postfix string
+        } else if (infix[i] == '(') { 
+            // 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
+        }    
+    } 
+    // pop all the operators from the s at the end of postfix
+    // and end the postfix with `\0`
+    return postfix;
+} 
+```
+
+
+# La calculatrice (7/8)
+
+## Évaluation d'expression postfixe: algorithme
+
+* Chaque *opérateur* porte sur les deux opérandes qui le précèdent.
+* Le *résultat d'une opération* est un nouvel *opérande* qui est remis au
+  sommet de la pile.
+
+## Exemple
+
+```C
+2 3 4 + * 5 - = ?
+```
+
+* On parcours de gauche à droite:
+
+```C
+Caractère lu        Pile opérandes
+    2               2
+    3               2, 3
+    4               2, 3, 4
+    +               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.
+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)
+
+. . .
+
+```C
+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]);
+        } else if (is_operator(postfix[i])) {
+            double rhs = stack_pop(&s);
+            double lhs = stack_pop(&s);
+            stack_push(&s, op(postfix[i], lhs, rhs));
+        }    
+    }
+    return stack_pop(&s);
+}
+```
+
+# Liste chaînée et pile
+
+\Huge Liste chaînée et pile
+
+# La liste chaînée et pile (1/6)
+
+## Structure de données
+
+* Chaque élément de la liste contient:
+    1. une valeur,
+    2. un pointeur vers le prochain élément.
+* La pile est un pointeur vers le premier élément.
+
+![Un exemple de liste chaînée.](figs/Singly-linked-list.svg){width=80%}
+
+# La liste chaînée et pile (2/6)
+
+## Une pile-liste-chaînée
+
+```C
+typedef struct _element {
+    int data;
+    struct _element *next;
+} element;
+typedef struct _stack {
+    element *top;
+} stack;
+```
+
+## Fonctionnalités?
+
+. . .
+
+```C
+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); // return NULL == s.top;
+```
+
+# La liste chaînée et pile (3/6)
+
+## Empiler? (faire un dessin)
+
+. . .
+
+```C
+
+
+
+
+
+
+
+```
+
+## Empiler? (le code ensemble)
+
+. . .
+
+```C
+void stack_push(stack *s, int val) {
+    element *elem = malloc(sizeof(*elem));
+    elem->data = val;
+    elem->next = s->top;
+    s->top = elem;
+}
+```
+
+# La liste chaînée et pile (4/6)
+
+## Jeter un oeil? (faire un dessin)
+
+. . .
+
+```C
+
+
+
+
+
+
+
+```
+
+## Jeter un oeil? (le code ensemble)
+
+. . .
+
+```C
+void stack_peek(stack s, int *val) {
+    *val = s.top->val;
+}
+```
+
+# La liste chaînée et pile (5/6)
+
+## Dépiler? (faire un dessin)
+
+. . .
+
+```C
+
+
+
+
+
+
+
+```
+
+## Dépiler? (le code ensemble)
+
+. . .
+
+```C
+void stack_pop(stack *s, int *val) {
+    stack_peek(*s, val);
+    element *tmp = s->top;
+    s->top = s->top->next;
+    free(tmp);
+}
+```
+
+# La liste chaînée et pile (6/6)
+
+## Détruire? (faire un dessin)
+
+. . .
+
+```C
+
+
+
+
+
+
+
+```
+
+## Détruire? (le code ensemble)
+
+. . .
+
+```C
+void stack_destroy(stack *s) {
+    while (!stack_is_empty(*s)) {
+        int val; 
+        stack_pop(s, &val);
+    }
+}
+```
+

slides/cours_12.md

+---
+title: "File d'attente, liste triée, liste doublement chaînée"
+date: "2024-12-16"
+---
+
+# 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.
+* 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 file vide.
+* Détruire une file.
+
+# La file d'attente (2/2)
+
+\footnotesize
+
+## Implémentation possible
+
+* 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%}
+
+## 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
+
+## Création 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 est la 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` serait un indice du tableau;
+* `capacity` serait 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 est 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;
+    }
+}
+```
+
+# Listes triées
+
+\Huge Les listes triées
+
+# 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 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 (1/3)
+
+## 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/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%}
+
+. . .
+
+```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.
+
+. . .
+
+![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
+
+1. L'élément à extraire n'est **pas** le premier élément de la liste
+
+. . .
+
+![Extraction d'un élément qui n'est pas le premier.](figs/sorted_list_extract_any.svg){width=70%}
+
+. . .
+
+\scriptsize
+
+```C
+sorted_list sorted_list_extract(sorted_list list, int val) {
+    element *prec = *crt = list; // needed to glue elements together
+    while (NULL != crt && val > crt->data) {
+    prec = crt;
+    crt = crt->next;
+ }
+    if (NULL != crt && prec != crt && crt->data == val) { // glue things together
+        prec->next = crt->next;
+        free(crt);
+    }
+    return list;
+}
+```
+
+# L'extraction (2/3)
+
+2. L'élément à extraire est le premier élément de la liste
+
+. . .
+
+![Extraction d'un élément qui est le premier.](figs/sorted_list_extract_first.svg){width=70%}
+
+. . .
+
+\footnotesize
+
+```C
+sorted_list sorted_list_extract(sorted_list list, int val) {
+    element *prec = *crt = list; // needed to glue elements together
+    while (NULL != crt && val > crt->data) {
+    prec = crt;
+    crt = crt->next;
+ }
+    // glue things together
+    if (NULL != crt && crt->data == val && prec == crt) {
+        list = list->next;
+        free(crt);
+    }
+    return list;
+}
+```
+
+# L'extraction (3/3)
+
+3. L'élément à extraire n'est **pas** dans la liste.
+    * La liste est vide.
+    * La valeur est plus grande que le dernier élément de la liste.
+    * La valeur est plus petite que la valeur de `crt`.
+
+. . .
+
+On retourne la liste inchangée.
+
+. . .
+
+\footnotesize
+
+```C
+sorted_list sorted_list_extract(sorted_list list, int val) {
+    element *prec = *crt = list; // needed to glue elements together
+    while (NULL != crt && val > crt->data) {
+    prec = crt;
+    crt = crt->next;
+ }
+    if (NULL == crt || crt->data != val) { // val not present
+        return list;
+    }
+}
+```
+
+# La recherche
+
+```C
+element* sorted_list_search(sorted_list list, int val);
+```
+
+* Retourne `NULL` si la valeur n'est pas présente (ou la liste vide).
+* Retourne un pointeur vers l'élément si la valeur est présente.
+
+. . .
+
+```C
+element* sorted_list_search(sorted_list list, int val) {
+    // search for element smaller than 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) 
+    {
+        return pos->next; // non-first element contains val
+    } else {
+        return NULL; // well... val's not here
+    }
+}
+```
+
+# La recherche
+
+## La fonction `sorted_list_position`
+
+```C
+element* sorted_list_position(sorted_list list, int val);
+```
+
+![Trois exemples de retour de la fonction `sorted_list_position()`.](figs/sorted_list_position.svg)
+
+# La recherche
+
+## Exercice: implémenter
+
+```C
+element* sorted_list_position(sorted_list list, int val);
+```
+
+. . .
+
+```C
+element* sorted_list_position(sorted_list list, int val) {
+    element* pos = list;
+    if (sorted_list_is_empty(list) || val <= list->data) {
+        pos = NULL;
+    } else {
+        while (NULL != pos->next && val > pos->next->data) {
+            pos = pos->next;
+        }
+    }
+    return pos;
+}
+```
+
+# Complexité de la liste chaînée triée
+
+## L'insertion?
+
+. . .
+
+$$
+\mathcal{O}(N).
+$$
+
+## L'extraction?
+
+. . .
+
+$$
+\mathcal{O}(N).
+$$
+
+## La recherche?
+
+. . .
+
+$$
+\mathcal{O}(N).
+$$
+
+# Liste doublement chaînée
+
+## Application: navigateur ou éditeur de texte
+
+* Avec une liste chaînée:
+  * Comment implémenter les fonctions `back` et `forward` d'un navigateur?
+  * Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?
+
+. . .
+
+Pas possible.
+
+## Solution?
+
+. . .
+
+* Garder un pointeur supplémentaire sur l'élément précédent et pas seulement le
+  suivant.
+
+. . .
+
+* Cette structure de donnée est la **liste doublement chaînée** ou **doubly
+  linked list**.
+
+# 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**
+
+![Un schéma de liste doublement chaînée d'entiers.](figs/doubly_linked_list.svg)
+
+1. Écrire les structures de données pour représenter la liste doublement
+   chaînée dont le type sera `dll` (pour
+   `doubly_linked_list`)
+
+# Liste doublement chaînée
+
+2. Écrire les fonctionnalités de création et consultation
+
+```C
+// crée la liste doublement chaînée
+dll dll_create();
+// retourne la valeur à la position actuelle dans la liste
+int dll_value(dll list);
+// la liste est-elle vide?
+bool dll_is_empty(dll list);
+// Est-ce que pos est le 1er élément?
+bool dll_is_head(dll list);
+// Est-ce que pos est le dernier élément?
+bool dll_is_tail(dll list);
+// data est-elle dans la liste?
+bool dll_is_present(dll list, int data);
+// affiche la liste
+void dll_print(dll list);
+```
+
+# Liste doublement chaînée
+
+3. Écrire les fonctionnalités de manipulation
+
+```C
+// déplace pos au début de la liste
+dll dll_move_to_head(dll list);
+// déplace pos à la position suivante dans la liste
+dll dll_next(dll list);
+// déplace pos à la position précédente dans la liste
+dll dll_prev(dll list);
+```
+
+# Liste doublement chaînée
+
+4. Écrire les fonctionnalités d'insertion
+
+```C
+// insertion de data dans l'élément après pos
+dll dll_insert_after(dll list, int data);
+// insertion de data en tête de liste
+dll dll_push(dll list, int data);
+```
+
+5. Écrire les fonctionnalités d'extraction
+
+```C
+// extraction de la valeur se trouvant dans l'élément pos
+// l'élément pos est libéré
+int dll_extract(dll *list);
+// extrait la donnée en tête de liste
+int dll_pop(dll *list);
+// vide la liste
+void dll_destroy(dll *list);
+```

slides/cours_13.md

+---
+title: "Liste triée, liste doublement chaînée"
+date: "2025-01-06"
+---
+
+# 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 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 (1/3)
+
+## 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/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%}
+
+. . .
+
+```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.
+
+. . .
+
+![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
+
+1. L'élément à extraire n'est **pas** le premier élément de la liste
+
+. . .
+
+![Extraction d'un élément qui n'est pas le premier.](figs/sorted_list_extract_any.svg){width=70%}
+
+. . .
+
+\scriptsize
+
+```C
+sorted_list sorted_list_extract(sorted_list list, int val) {
+    element *prec = *crt = list; // needed to glue elements together
+    while (NULL != crt && val > crt->data) {
+    prec = crt;
+    crt = crt->next;
+ }
+    if (NULL != crt && prec != crt && crt->data == val) { // glue things together
+        prec->next = crt->next;
+        free(crt);
+    }
+    return list;
+}
+```
+
+# L'extraction (2/3)
+
+2. L'élément à extraire est le premier élément de la liste
+
+. . .
+
+![Extraction d'un élément qui est le premier.](figs/sorted_list_extract_first.svg){width=70%}
+
+. . .
+
+\footnotesize
+
+```C
+sorted_list sorted_list_extract(sorted_list list, int val) {
+    element *prec = *crt = list; // needed to glue elements together
+    while (NULL != crt && val > crt->data) {
+    prec = crt;
+    crt = crt->next;
+ }
+    // glue things together
+    if (NULL != crt && crt->data == val && prec == crt) {
+        list = list->next;
+        free(crt);
+    }
+    return list;
+}
+```
+
+# L'extraction (3/3)
+
+3. L'élément à extraire n'est **pas** dans la liste.
+    * La liste est vide.
+    * La valeur est plus grande que le dernier élément de la liste.
+    * La valeur est plus petite que la valeur de `crt`.
+
+. . .
+
+On retourne la liste inchangée.
+
+. . .
+
+\footnotesize
+
+```C
+sorted_list sorted_list_extract(sorted_list list, int val) {
+    element *prec = *crt = list; // needed to glue elements together
+    while (NULL != crt && val > crt->data) {
+    prec = crt;
+    crt = crt->next;
+ }
+    if (NULL == crt || crt->data != val) { // val not present
+        return list;
+    }
+}
+```
+
+# La recherche
+
+```C
+element* sorted_list_search(sorted_list list, int val);
+```
+
+* Retourne `NULL` si la valeur n'est pas présente (ou la liste vide).
+* Retourne un pointeur vers l'élément si la valeur est présente.
+
+. . .
+
+```C
+element* sorted_list_search(sorted_list list, int val) {
+    // search for element smaller than 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) 
+    {
+        return pos->next; // non-first element contains val
+    } else {
+        return NULL; // well... val's not here
+    }
+}
+```
+
+# La recherche
+
+## La fonction `sorted_list_position`
+
+```C
+element* sorted_list_position(sorted_list list, int val);
+```
+
+![Trois exemples de retour de la fonction `sorted_list_position()`.](figs/sorted_list_position.svg)
+
+# La recherche
+
+## Exercice: implémenter
+
+```C
+element* sorted_list_position(sorted_list list, int val);
+```
+
+. . .
+
+```C
+element* sorted_list_position(sorted_list list, int val) {
+    element* pos = list;
+    if (sorted_list_is_empty(list) || val <= list->data) {
+        pos = NULL;
+    } else {
+        while (NULL != pos->next && val > pos->next->data) {
+            pos = pos->next;
+        }
+    }
+    return pos;
+}
+```
+
+# Complexité de la liste chaînée triée
+
+## L'insertion?
+
+. . .
+
+$$
+\mathcal{O}(N).
+$$
+
+## L'extraction?
+
+. . .
+
+$$
+\mathcal{O}(N).
+$$
+
+## La recherche?
+
+. . .
+
+$$
+\mathcal{O}(N).
+$$
+
+# Liste doublement chaînée
+
+## Application: navigateur ou éditeur de texte
+
+* Avec une liste chaînée:
+  * Comment implémenter les fonctions `back` et `forward` d'un navigateur?
+  * Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?
+
+. . .
+
+Pas possible.
+
+## Solution?
+
+. . .
+
+* Garder un pointeur supplémentaire sur l'élément précédent et pas seulement le
+  suivant.
+
+. . .
+
+* Cette structure de donnée est la **liste doublement chaînée** ou **doubly
+  linked list**.
+
+# 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**
+
+![Un schéma de liste doublement chaînée d'entiers.](figs/doubly_linked_list.svg)
+
+1. Écrire les structures de données pour représenter la liste doublement
+   chaînée dont le type sera `dll` (pour
+   `doubly_linked_list`)
+
+# Liste doublement chaînée
+
+2. Écrire les fonctionnalités de création et consultation
+
+```C
+// crée la liste doublement chaînée
+dll dll_create();
+// retourne la valeur à la position actuelle dans la liste
+int dll_value(dll list);
+// la liste est-elle vide?
+bool dll_is_empty(dll list);
+// Est-ce que pos est le 1er élément?
+bool dll_is_head(dll list);
+// Est-ce que pos est le dernier élément?
+bool dll_is_tail(dll list);
+// data est-elle dans la liste?
+bool dll_is_present(dll list, int data);
+// affiche la liste
+void dll_print(dll list);
+```
+
+# Liste doublement chaînée
+
+3. Écrire les fonctionnalités de manipulation
+
+```C
+// déplace pos au début de la liste
+dll dll_move_to_head(dll list);
+// déplace pos à la position suivante dans la liste
+dll dll_next(dll list);
+// déplace pos à la position précédente dans la liste
+dll dll_prev(dll list);
+```
+
+# Liste doublement chaînée
+
+4. Écrire les fonctionnalités d'insertion
+
+```C
+// insertion de data dans l'élément après pos
+dll dll_insert_after(dll list, int data);
+// insertion de data en tête de liste
+dll dll_push(dll list, int data);
+```
+
+5. Écrire les fonctionnalités d'extraction
+
+```C
+// extraction de la valeur se trouvant dans l'élément pos
+// l'élément pos est libéré
+int dll_extract(dll *list);
+// extrait la donnée en tête de liste
+int dll_pop(dll *list);
+// vide la liste
+void dll_destroy(dll *list);
+```
+

slides/cours_14.md

+---
+title: "Tables de hachage"
+date: "2025-02-21"
+---
+
+# 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, key_value_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)
+
+\footnotesize
+
+## 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.
+$$

slides/cours_15.md

+---
+title: "Fin des tables de hachages et arbres"
+date: "2025-02-28"
+---
+
+# Rappel
+
+* Qu'est-ce qu'une table de hachage?
+
+. . .
+
+* Structure de données abstraite où chaque *valeur* (ou élément) est associée à une *clé* (ou argument).
+* Quelles sont les fonctions typiques définies sur les tables?
+
+. . .
+
+* Insertion, consultation, suppression.
+
+    ```C
+    void insert(table, key, value)
+    value get(table, key)
+    value remove(table, key)
+    ```
+
+* Comment fait-on le lien entre une clé et une valeur dans le tableau?
+
+. . .
+
+* On hache!
+
+# 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*}
+* En cas de collision, on fait un saut de $h_2(k)$, c.-à-d. $$index = (index + h_2(k)) \mod 13.$$
+
+
+# Exercice 3
+
+* 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
+$$
+h(N)=N\mod 10.
+$$
+* La fonction de gestion des collisions est
+$$
+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.
+* 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.
+$$
+
+# Préambule
+
+\small
+
+* 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
+    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;
+    ```
+\normalsize
+
+* Gestion de l'état d'une case *explicite*
+
+    ```C
+    typedef enum {EMPTY, OCCUPIED, DELETED} state;
+    ```
+
+# L'insertion
+
+## Pseudocode?
+
+. . .
+
+```C
+rien insertion(table, clé, valeur) {
+    index = hash(clé)
+    index = 
+        tant que état(table[index]) == occupé 
+                 et clé(table[index]) != clé:
+            index = rehash(clé)
+
+    état(table[index]) = occupé
+    table[index] = valeur
+}
+```
+
+# La suppression
+
+## Pseudocode?
+
+. . .
+
+```C
+valeur suppression(table, clé):
+    index = hash(clé)
+    tant que état(table[index]) != vide:
+        si état(table[index]) == occupé 
+                et clé(table[index]) == clé:
+            état(table[index]) = supprimé
+        sinon
+            index = rehash(clé)
+}
+```
+
+# La recherche
+
+## Pseudocode?
+
+. . .
+
+```C
+booléen recherche(table, clé) {
+    index = hash(clé)
+    tant que état(table[index]) != vide:
+        si état(table[index]) == occupé 
+                et clé(table[index]) == clé:
+            retourner vrai
+        sinon
+            index = rehash
+    retourner faux
+}
+```
+
+# Écrivons le code!
+
+* Mais avant:
+    * Quelles sont les structures de données dont nous avons besoin?
+    * Y a-t-il des fonctions auxiliaires à écrire?
+    * Écrire les signatures des fonctions.
+
+. . .
+
+## Structures de données
+
+\footnotesize
+
+. . .
+
+```C
+typedef enum {empty, deleted, occupied};
+typedef ... key_t;
+typedef ... value_t;
+typedef struct _cell_t {
+    key_t key; 
+    value_t value;
+    state_t state;
+} cell_t;
+typedef struct _hm {
+    cell_t *table;
+    int capacity;
+    int size;
+} hm;
+```
+
+# Écrivons le code!
+
+## Fonctions auxiliaires
+
+. . .
+
+```C
+static int hash(key_t key);
+static int rehash(int index, key_t key);
+static int find_index(hm h, key_t key);
+```
+
+##  Signature de l'API 
+
+. . .
+
+```C
+void hm_init(hm *h, int capacity);
+void hm_destroy(hm *h);
+bool hm_set(hm *h, key_t key, value_t *value);
+bool hm_get(hm h, key_t key, value_t *value);
+bool hm_remove(hm *h, key_t key, value_t *value);
+bool hm_search(hm h, key_t key);
+void hm_print(hm h);
+```
+
+# Live code session! 
+
+0. Offered to you by ProtonVPN[^1]!
+
+. . .
+
+1. Like the video.
+2. Subscribe to the channel.
+3. Use our one time voucher for ProtonVPN: `PAULISAWESOME`.
+4. Consider donating on our patreon.
+
+[^1]: The fastest way to connect to BBB!
+
+# Les arbres
+
+\Huge Les arbres
+
+# 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ésentations
+
+* 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ésentations
+
+* 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ésentations
+
+* 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
+```
+::::
+
+:::
+

slides/cours_16.md

+---
+title: "Arbres binaires"
+date: "2025-03-07"
+---
+
+# Les arbres binaires
+
+\Huge Les arbres binaires
+
+# L'arbre binaire
+
+* Structure de données abstraite,
+* Chaque nœud a au plus deux enfants: gauche et droite,
+* Chaque enfant est un arbre.
+
+## Comment représenteriez vous une telle structure?
+
+. . .
+
+```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;
+```
+
+# L'arbre binaire
+
+\footnotesize
+
+## 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 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.
+
+::::
+
+:::
+
+# 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 n'est pas vide.
+    2. On visite la racine du sous arbre.
+    3. On descend dans le sous-arbre de droite (s'il n'est pas vide).
+    4. On recommence.
+
+. . .
+
+## Incompréhensible?
+
+* La récursivité, c'est la vie.
+    
+```
+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;
+void tree_print(node *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** 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(node *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(node *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$:
+    * Toute clé du sous-arbre à gauche de $N$ est inférieure à 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
+tree recherche(clé, arbre)
+    tant_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 > key) {
+            current = current->left;
+        } else if (current->key < key){
+            current = current->right;
+        } 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 tree_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 ne 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
+
+```
+tree 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/4)
+
+* Deux parties:
+    * Recherche de la position.
+    * Ajout dans l'arbre.
+
+## Ajout de l'enfant
+
+```
+rien 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
+node *position(node *tree, key_t key) {
+    node * current = tree;
+    if (NULL != current) {
+        node *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;
+}
+```
+
+# 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.
+

slides/cours_17.md

+---
+title: "Arbres binaires, tri par tas"
+date: "2025-03-14"
+---
+
+# Les arbres binaires
+
+\Huge Les arbres binaires
+
+# Rappel pour l'insertion
+
+* Les éléments insérés ont une notion d'ordre
+* On parcourt l'arbre jusqu'à pouvoir ajouter une nouvelle feuille
+
+# Pseudo-code d'insertion (1/4)
+
+\footnotesize
+
+* Deux parties:
+    * Recherche le parent où se passe l'insertion.
+    * Ajout de l'enfant dans l'arbre.
+
+## Recherche du parent
+
+```python
+arbre position(tree, clé)
+    si est_non_vide(tree)
+        si clé < clé(tree)
+            suivant = gauche(tree)
+        sinon
+            suivant = droite(tree)
+        tant que clé(tree) != clé && est_non_vide(suivant)
+            tree = suivant
+            si clé < clé(tree)
+                suivant = gauche(tree)
+            sinon
+                suivant = droite(tree)
+            
+    retourne tree
+```
+
+# Pseudo-code d'insertion (2/4)
+
+* Deux parties:
+    * Recherche de la position.
+    * Ajout dans l'arbre.
+
+## Ajout de l'enfant
+
+```
+rien ajout(tree, clé)
+    si est_vide(tree)
+        tree = nœud(clé)
+    sinon
+        si clé < clé(tree)
+            gauche(tree) = nœud(clé)
+        sinon si clé > clé(tree)
+            droite(tree) = nœud(clé)
+        sinon
+            retourne
+```
+
+# Code d'insertion en C
+
+## Recherche du parent (ensemble)
+
+. . .
+
+```C
+node *position(node *tree, key_t key) {
+    node * current = tree;
+    if (NULL != current) {
+        node *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;
+}
+```
+
+# L'insertion (3/4)
+
+* Deux parties:
+    * Recherche de la position.
+    * Ajout dans l'arbre.
+
+## Ajout du fils (pseudo-code)
+
+```
+rien ajout(tree, clé)
+    si est_vide(tree)
+        tree = nœud(clé)
+    sinon
+        tree = position(tree, clé)
+        si clé < clé(tree)
+            gauche(tree) = nœud(clé)
+        sinon si clé > clé(tree)
+            droite(tree) = 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 dans un arbre binaire
+
+\Huge La suppression dans un arbre binaire
+
+# 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-->19
+    20-->21
+```
+
+::::
+
+:::: 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)
+
+```
+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;
+}
+``` -->
+
+

slides/cours_18.md

+---
+title: "Arbres AVL"
+date: "2025-03-21"
+---
+
+# Exercice (que vous avez dû faire à la maiso)
+
+* 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;
+}
+``` -->
+
+
+
+
+# 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))$?
+
+. . .
+
+* Si on a environ le même nombre de nœuds dans les sous-arbres.
+
+## Définition
+
+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.
+* Quelle est la hauteur (profondeur) d'un arbre parfaitement équilibré?
+
+. . .
+
+* $O(\log_2(N))$.
+
+
+# Équilibre parfait ou pas?
+
+::: columns
+
+:::: column
+
+```{.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
+
+. . .
+
+```
+É
+Q
+U
+I
+L
+I
+B
+R
+É
+```
+
+::::
+
+:::
+
+# Équilibre parfait ou pas?
+
+::: columns
+
+:::: column
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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
+```
+
+::::
+
+:::: column
+
+. . .
+
+```
+P 
+A
+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}`
+
+
+# AVL ou pas?
+
+::: columns
+
+:::: column
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((12))-->id1((10));
+    id0-->id2((19));
+    id2-->id3((17));
+    id2-->id4((97));
+```
+
+::::
+
+:::: column
+
+. . .
+
+```
+A
+V
+L
+```
+
+::::
+
+:::
+
+# AVL ou pas?
+
+::: columns
+
+:::: column
+
+```{.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
+```
+
+::::
+
+:::: column
+
+. . .
+
+```
+P
+A
+S
+
+A
+V
+L
+```
+
+::::
+
+:::
+
+# 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));
+```
+
+::::
+
+:::: column
+
+. . .
+
+* `hd = hg`
+
+```{.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`
+
+::::
+
+:::
+
+# Insertion dans un arbre AVL (2/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));
+    id2-->id3((18));
+    id2-->id4((  ));
+    style id4 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+. . .
+
+* `hd < hg`
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((12))-->id1((1));
+    id0-->id2((19));
+    id2-->id3((18));
+    id2-->id4((  ));
+    id1-->id5((  ));
+    id1-->id6((4));
+    style id4 fill:#fff,stroke:#fff
+    style id5 fill:#fff,stroke:#fff
+```
+
+* `fe = 0`
+
+::::
+
+:::
+
+# Insertion dans un arbre AVL (3/N)
+
+\footnotesize
+
+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));
+    id1-->id3((  ));
+    id1-->id4((6));
+    id2-->id5((  ));
+    id2-->id6((  ));
+    style id3 fill:#fff,stroke:#fff
+    style id5 fill:#fff,stroke:#fff
+    style id6 fill:#fff,stroke:#fff
+```
+
+::::
+
+:::: column
+
+. . .
+
+* `hd < hg`
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((12))-->id1((1));
+    id0-->id2((19));
+    id1-->id3((  ));
+    id1-->id4((6));
+    id4-->id5((4));
+    id4-->id6((  ));
+    id2-->id7((  ));
+    id2-->id8((  ));
+    style id3 fill:#fff,stroke:#fff
+    style id6 fill:#fff,stroke:#fff
+    style id7 fill:#fff,stroke:#fff
+    style id8 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)
+
+::::
+
+:::
+
+# Les cas de déséquilibre
+
+
+::: columns
+
+:::: 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
+
+## Cas 2a
+
+* `h(v1)=h(v2), h(u)=h(w)`.
+* déséquilibre en `C` après insertion dans `v2`
+
+![Après insertion](figs/cas2a_gauche.png)
+
+::::
+
+:::: 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`)
+* `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)
+
+::::
+
+:::: 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))
+```
+
+## Valeurs possibles?
+
+. . .
+
+```
+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
+
+## Sous-arbre gauche (avant)
+
+```
+fe(P) =  1 
+fe(P) =  0 
+fe(P) = -1 
+```
+
+::::
+
+:::: column
+
+## Sous-arbre gauche (après)
+
+. . .
+
+```
+=> fe(P) =  0 
+=> fe(P) = -1 
+=> fe(P) = -2 // Rééquilibrer P
+```
+
+::::
+
+:::
+
+# 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
+
+## Sous-arbre droit (avant)
+
+```
+fe(P) =  1 
+fe(P) =  0 
+fe(P) = -1 
+```
+
+::::
+
+:::: column
+
+## Sous-arbre droit (après)
+
+. . .
+
+```
+=> fe(P) =  0 
+=> fe(P) = +1 
+=> fe(P) = +2 // Rééquilibrer P
+```
+
+::::
+
+:::
+
+# Rééquilibrage
+
+## Lien avec les cas vus plus tôt
+
+```
+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
+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)
+
+# La rotation
+
+## La rotation gauche (5min, matrix)
+
+![L'arbre de droite devient celui de gauche. Comment?](figs/rotation_gauche_droite.png)
+
+. . .
+
+\footnotesize
+```
+arbre rotation_gauche(arbre P) 
+    si est_non_vide(P)
+        Q = droite(P)
+        droite(P) = gauche(Q)
+        gauche(Q) = P
+        retourne Q
+    retourne P
+```
+
+# La rotation en C (1/2)
+
+## La rotation gauche
+
+```
+arbre rotation_gauche(arbre P) 
+    si est_non_vide(P)
+        Q = droite(P)
+        droite(P) = gauche(Q)
+        gauche(Q) = P
+        retourne Q
+    retourne P
+```
+
+## Écrire le code C correspondant (5min, matrix)
+
+1. Structure de données
+2. Fonction `tree_t rotation_left(tree_t tree)`
+
+. . .
+
+\footnotesize
+```C
+typedef struct _node {
+    int key;
+    struct _node *left, *right;
+    int bf; // balance factor
+} node;
+typedef node *tree_t;
+```
+
+# La rotation en C (2/2)
+
+\footnotesize
+
+```C
+tree_t rotation_left(tree_t tree) {
+    tree_t subtree = NULL;
+    if (NULL != tree) {
+        subtree = tree->right;
+        tree->right = subtree->left;
+        subtree->left = tree;
+    }
+    return subtree;
+}
+```
+
+. . .
+
+* Et la rotation à droite, pseudo-code (5min)?
+
+. . .
+
+```
+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)
+
+## 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)
+
+::: columns
+
+:::: column
+
+## 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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## 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));
+```
+
+::::
+
+:::
+
+* 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
+
+## Faire l'implémentation de la double rotation (pas corrigé, 5min)
+
+# Exercices
+
+::: columns
+
+:::: column
+
+## Insérer 50, ex 10min (matrix)
+
+```{.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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## 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
+```
+
+::::
+
+:::
+
+# Exercices
+
+::: columns
+
+:::: column
+
+## Rotation gauche en 44
+
+```{.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
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    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
+
+Soit l’arbre AVL suivant:
+
+::: columns
+
+:::: column
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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 
+    | 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
+
+## Algorithme par problème: supprimer 10
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## Algorithme par problème: supprimer 10
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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
+```
+
+::::
+
+:::
+
+# Suppression dans un arbre AVL
+
+
+::: columns
+
+:::: column
+
+## Algorithme par problème: supprimer 8
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## 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.
+2. On rééquilibre si besoin à l'endroit de la suppression.
+
+* Facile non?
+
+. . .
+
+* Plus dur....
+
+::::
+
+:::
+
+# Suppression dans un arbre AVL 2.0
+
+::: 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
+
+. . .
+
+## Algorithme par problème: rotation GD autour de 40
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((50))-->id1((40));
+    id0-->id2((100));
+    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
+```
+
+::::
+
+:::
+
+# Suppression dans un arbre AVL 2.0
+
+::: columns
+
+:::: column
+
+## Argl! 50 est déséquilibré!
+
+```{.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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## Algorithme par problème: rotation DG autour de 50
+
+```{.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
+```
+
+::::
+
+:::
+
+# 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.

slides/cours_19.md

+---
+title: "Arbres AVL et arbres quaternaires"
+date: "2025-03-28"
+---
+
+# Rappel: 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.
+
+# Rappel: 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)
+
+::::
+
+:::
+
+# Rappel: Les cas de déséquilibre
+
+
+::: columns
+
+:::: column
+
+## Cas 2a
+
+* `h(v1)=h(v2), h(u)=h(w)`.
+* déséquilibre en `C` après insertion dans `v2`
+
+![Après insertion](figs/cas2a_gauche.png)
+
+::::
+
+:::: 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`)
+* `B` à droite de `A` (gauche de `C`)
+* `v1` à droite de `A` (gauche de `B`)
+
+![Après équilibrage](figs/cas2a_droite.png)
+
+::::
+
+:::
+
+# Rappel: Rééquilibrage
+
+## Rotation simple
+
+![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
+
+# Rappel: La rotation gauche-droite
+
+## Le cas 2a/b
+
+![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
+
+```
+25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40 
+    | 50 | 55 | 30 | 15
+```
+
+```
+
+
+
+
+
+
+
+
+
+
+```
+
+# La suppression dans un arbre AVL
+
+\Huge La suppression dans un arbre AVL
+
+# Suppression dans un arbre AVL
+
+::: columns
+
+:::: column
+
+## Algorithme par problème: supprimer 10
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## Algorithme par problème: supprimer 10
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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
+```
+
+::::
+
+:::
+
+# Suppression dans un arbre AVL
+
+
+::: columns
+
+:::: column
+
+## Algorithme par problème: supprimer 8
+
+```{.mermaid format=pdf width=400 loc=figs/}
+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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## 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.
+2. On rééquilibre si besoin à l'endroit de la suppression.
+
+* Facile non?
+
+. . .
+
+* Plus dur....
+
+::::
+
+:::
+
+# Suppression dans un arbre AVL 2.0
+
+::: 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
+
+. . .
+
+## Algorithme par problème: rotation GD autour de 40
+
+```{.mermaid format=pdf width=400 loc=figs/}
+graph TD;
+    id0((50))-->id1((40));
+    id0-->id2((100));
+    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
+```
+
+::::
+
+:::
+
+# Suppression dans un arbre AVL 2.0
+
+::: columns
+
+:::: column
+
+## Argl! 50 est déséquilibré!
+
+```{.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
+```
+
+::::
+
+:::: column
+
+. . .
+
+## Algorithme par problème: rotation DG autour de 50
+
+```{.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
+```
+
+::::
+
+:::
+
+# 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 arbres quaternaires
+
+\Huge Les arbres quaternaires
+
+
+# Les arbres quaternaires
+
+## Définition
+
+Arbre dont chaque nœud a 4 enfants ou aucun. 
+
+![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 (algorithme de Barnes-Hut).
+
+# Exemple de compression
+
+::: columns
+
+:::: {.column width=30%}
+
+## Comment représenter l'image
+
+![Image noir/blanc.](figs/board_blacked_parts.svg)
+
+::::
+
+:::: {.column width=70%}
+
+## Sous la forme d'un arbre quaternaire?
+
+. . .
+
+![L'arbre quaternaire correspondant.](figs/quad_img.svg)
+
+**Économie?**
+
+. . .
+
+Image 64 pixels, arbre 25 nœuds.
+
+::::
+
+:::
+
+
+# Structure de données
+
+::: columns
+
+:::: {.column width=50%}
+
+## Pseudo-code?
+
+. . .
+
+```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%}
+
+## En C?
+
+. . .
+
+```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?
+
+. . .
+
+* Type récursif => taille inconnue à la compilation.
+
+::::
+
+:::
+
+# Une fonctionnalité simple
+
+\footnotesize
+
+## La fonction `est_feuille(noeud)`
+
+* 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!)
+* Facile d'en oublier un!
+* Comment changer la structure pour que ça soit moins terrible?
+
+. . .
+
+```python
+struct node
+    info
+    node enfant[4]
+```
+
+# Structure de données
+
+## En C?
+
+. . .
+
+```C 
+typedef struct _node {
+    int info;
+    struct _node *child[4];
+} node;
+```
+
+## Fonction `is_leaf(node *tree)`?
+
+. . .
+
+```C 
+bool is_leaf(node *tree) {
+    return (NULL == tree->child[0]); // only first matters
+}
+```
+
+# Problème à résoudre
+
+* 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)
+
+# Création de l'arbre
+
+## Comment créer un arbre de profondeur `prof` (3min)?
+
+. . .
+
+```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)?
+
+. . .
+
+```C
+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 implémenter la fonction (pseudo-code, 5min, matrix)?
+
+. . .
+
+```C
+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
+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)
+
+. . .
+
+\footnotesize
+
+```C
+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 remplir un arbre depuis une matrice?
+
+```
+   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?
+
+. . .
+
+![L'arbre correspondant](figs/quad_img_simple.svg)
+
+# Fonctions utiles (2/4)
+
+* On veut transférer la valeur d'une case ligne/colonne dans une feuille.
+* Comment?
+
+::: columns
+
+:::: {.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
+```
+
+::::
+
+:::: {.column width=70%}
+
+## Trouver un algorithme
+
+![Déterminer un algorithme.](figs/quad_img_simple.svg)
+
+* Quelle feuille pour 31 (`li=2`, `co=3`)?
+* Plus important: quel chemin?
+
+. . .
+
+* `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`
+* Comment généraliser?
+
+::::
+
+:::
+
+# Fonctions utiles (3/4)
+
+::: columns
+
+:::: {.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
+```
+
+::::
+
+:::: {.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
+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
+```
+
+
+::::
+
+:::
+
+# 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
+
+
+
+
+
+
+
+
+
+
+
+```
+
+# Remplir l'arbre
+
+## A partir d'une matrice (pseudo-code, 5min, matrix)?
+
+. . .
+
+```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)
+            noeud.info = matrice[co][li]
+    retourne arbre
+```
+
+. . .
+
+## A partir d'une matrice (C, 5min, matrix)?
+
+. . .
+
+\footnotesize
+
+```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 < nb_li; ++li) {
+        for (int co = 0; co < nb_co; ++co) {
+            node *current = position(li, co, qt);
+            current->info = matrix[li][co];
+        }
+    }
+    return qt;
+}
+```
+
+
+# Remplir la matrice
+
+## A partir de l'arbre (pseudo-code, 3min, matrix)?
+
+. . .
+
+\footnotesize
+
+```C
+matrice arbre_vers_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)?
+
+. . .
+
+\footnotesize
+
+```C
+void qt_to_matrix(node *qt, int nb_li, int nb_co, int matrix[nb_li][nb_co]) {
+    for (int li = 0; li < nb_li; ++li) {
+        for (int co = 0; co < nb_co; ++co) {
+            node *current = position(li, co, qt);
+            matrix[li][co] = current->info;
+        }
+    }
+}
+```
+
+

slides/cours_2.md

 ---
-title: "Introduction aux algorithmes"
-date: "2023-09-26"
+title: "Introduction aux algorithmes II"
+date: "2024-09-23"
 ---
 
 # Rappel

slides/cours_20.md

+---
+title: "Arbres quaternaires"
+date: "2025-04-04"
+---
+
+# Rappel sur les arbres quaternaires
+
+## Définition?
+
+. . .
+
+* Arbre dont chaque nœud a 4 enfants ou aucun. 
+
+## Utilisation dans ce cours?
+
+. . .
+
+* Stockage/compression d'image
+* Chaque pixel correspond à une feuille
+* Des portions de l'image peuvent être compressées sans/avec perte
+
+
+
+# Transformations avec un arbre quaternaire
+
+## A faire
+
+* Symétrie axiale (horizontale/verticale).
+* Rotation quart de cercle (gauche/droite).
+* Compression.
+
+# La symétrie verticale
+
+## 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
+```
+
+. . .
+
+```
+   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
+
+## Comment faire sur une matrice (3min, matrix)?
+
+. . .
+
+\footnotesize
+
+```C
+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
+```
+
+# La symétrie d'axe vertical
+
+## Comment faire sur un arbre?
+
+* 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 | 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
+
+```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?
+
+* 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
+
+    ```
+
+* Écrire le pseudo-code (3min, matrix)
+
+. . .
+
+```C
+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
+
+\footnotesize
+
+## Comment faire sur un arbre?
+
+```
+   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 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)
+
+* 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)
+
+. . .
+
+```C
+rien compression_sans_perte(arbre)
+    si !est_feuille(arbre)
+        pour i de 0 à 3
+            compression_sans_perte(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) {
+    if (!is_leaf(qt)) {
+        for (int i=0; i<CHILDREN; i++) {
+            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<CHILDREN; ++i) {  
+                    free(qt->child[i]);
+                    qt->child[i] = NULL;
+                }
+            }
+        }
+    }
+}
+```
+
+# Compression sans perte (5/5)
+
+\footnotesize
+
+```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;
+}
+```
+
+
+# Compression avec perte (1/5)
+
+## Idée générale
+
+* Regrouper les pixels par valeur sous certaines conditions
+
+```
+   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$, où $\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
+    flottant moyenne, moyenne_carre
+    node enfants[4]
+```
+
+* Comment on calcule `moyenne` et `moyenne_carre` sur chaque nœud (pseudo-code)?
+
+# Calcul de la moyenne
+
+## Pseudo-code (5min, matrix)
+
+. . .
+
+```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
+
+\footnotesize
+
+## Pseudo-code (5min, matrix)
+
+. . .
+
+```C
+rien compression_avec_pertes(arbre, theta)
+    si !est_feuille(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)
+moyenne(arbre)
+compression_avec_pertes(arbre)
+```
+
+# La dynamique des corps célestes
+
+## 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.
+* 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
+    flottant m
+    vec x, x_precedent, f
+```
+
+## Pseudo-code: itération temporelle
+
+```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)
+```
+
+# 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 le temps pour $N=1$ est environ $1\mu s$, on a:
+
++--------+-------+-------+-----------+
+|     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 alléger la représentation.
+* 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.
+
+# Algorithme d'insertion
+
+## Structure de données
+
+```C
+struct node
+    etoile e // externe: pour stocker 
+    etoile sup_etoile // interne: pour stocker m, x
+    quadrant q  // coordonnées du quadrant
+    node enfants[4]
+```
+
+## Remarque: 
+
+* On fait une simplification "moche": `sup_etoile` pourrait juste avoir une masse et une position.
+
+# Algorithme d'insertion
+
+\footnotesize
+
+## Algorithme d'insertion, pseudo-code (15min, matrix)
+
+. . .
+
+```C
+rien insertion_etoile(arbre, e)  
+    si (!est_vide(arbre) && dans_le_quadrant(arbre.q, e.x)) {
+        si (est_feuille(arbre))
+            si (!contient_etoile(arbre))
+                arbre.e = e
+            sinon
+                // on crée enfants et arbre.sup_etoile est initialisée
+                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)
+```
+
+# Utilisation de l'arbre
+
+* 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)
+
+* La distance entre `1` et le centre de masse de SG est `d`.
+
+# Calcul de la force
+
+## Calcul de la force sur `1`
+
+![](figs/force_4.png)
+
+* 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`.
+
+# Critère $\theta$
+
+* On compare $d=||\vec x_1-\vec x_{cm}||$ avec $s$ la taille du quadrant.
+* Le domaine est assez éloigné si
+
+    $$
+    \frac{s}{d}<\theta,
+    $$
+* $\theta$ est la valeur de seuil.
+* Une valeur typique est $\theta=0.5$, donc la condition devient
+
+    $$
+    d>2s.
+    $$
+
+# Calcul de la force
+
+## Calcul de la force sur `1`
+
+![](figs/force_4.png)
+
+* Ici $d<2s$, domaine rejeté.
+* On descend dans l'arbre.
+
+# Calcul de la force
+
+## 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
+
+## 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
+rien maj_force_sur_etoile(arbre, e, theta)
+    si est_vide(arbre)
+        retourne
+
+    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)
+```
+

slides/cours_21.md

+---
+title: "Les B-arbres"
+date: "2025-04-11"
+---
+
+# Les B-arbres
+
+\Huge
+
+Les B-arbres
+
+
+# Les B-arbres
+
+## Problématique
+
+* 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.
+
+## Exemple
+
+* 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}$.
+
+## Remarques
+
+* On ne sait pas ce que veut dire `B`: Bayer, Boeing, Balanced?
+* Variante plus récente B+-arbres.
+
+# Les B-arbres
+
+## Illustration, arbre divisé en pages de 3 nœuds
+
+![Arbre divisé en pages de 3 nœuds](figs/barbres_page3.png)
+
+. . .
+
+## Utilisation
+
+* Bases de données (souvent très grandes donc sur le disque);
+* Systèmes de fichiers.
+
+# Les B-arbres
+
+## Avantages
+
+* Arbres moins profonds;
+* Diminution des opérations de rééquilibrage;
+* Complexité toujours en $\log(N)$;
+
+. . .
+
+## 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
+
+## Est-ce un B-arbre?
+
+![B-arbre d'ordre 2.](figs/barbres_exemple.png)
+
+. . .
+
+## Oui!
+
+* 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
+
+## Exemple de recherche: trouver `32`
+
+![B-arbre d'ordre 2.](figs/barbres_exemple.png)
+ 
+. . .
+
+* Si `C` plus petit que la 1ère clé ou plus grand que la dernière descendre.
+* Sinon parcourir (par bissection ou séquentiellement) jusqu'à trouver où descendre entre 2 éléments.
+
+# Les B-arbres
+
+## Algorithme de recherche de la clé `C` 
+
+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
+
+* Inspiration de <https://en.wikipedia.org/wiki/B-tree>
+
+## Exemples d'insertion: `1`
+
+![B-arbre d'ordre 1.](figs/barbres_1.svg)
+ 
+. . .
+
+* L'arbre est vide, on insère juste dans la première page.
+
+# Les B-arbres
+
+## Exemples d'insertion: `2`
+
+![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_2.svg)
+ 
+. . .
+
+* La première page n'est pas pleine, on insère dans l'ordre (après 1).
+
+# Les B-arbres
+
+## Exemples d'insertion: `3`
+
+![B-arbre d'ordre 1.](figs/barbres_2.svg){width=50%}
+
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
+
+# Les B-arbres
+
+## Exemples d'insertion: `3`
+
+![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_3.svg){width=50%}
+ 
+. . .
+
+* La page est pleine, on crée deux enfants.
+* On choisit, `2`, la médiane de `1, 2, 3` et il est inséré à la racine.
+* `1` descend à gauche, `3` descend à droite.
+
+# Les B-arbres
+
+## Exemples d'insertion: `4`
+
+![B-arbre d'ordre 1.](figs/barbres_3.svg){width=50%}
+ 
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
+
+# Les B-arbres
+
+## Exemples d'insertion: `4`
+
+![B-arbre d'ordre 1. Nombre enfants 0 ou 2.](figs/barbres_4.svg){width=50%}
+ 
+. . .
+
+* On pourrait insérer à droite de `2`, mais... ça ferait 2 parents pour 2 enfants (mais `m` parents => `m+1` enfants ou `0`);
+* On descend à droite (`4 > 2`);
+* On insère à droite de `3`.
+
+# Les B-arbres
+
+## Exemples d'insertion: `5`
+
+![B-arbre d'ordre 1.](figs/barbres_4.svg){width=50%}
+ 
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
+
+# Les B-arbres
+
+## Exemples d'insertion: `5`
+
+![B-arbre d'ordre 1.](figs/barbres_5.svg)
+ 
+. . .
+
+* On descend à droite (on ne peut pas insérer à la racine comme pour `4`);
+* On dépasse la capacité de l'enfant droite;
+* `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.
+
+# Les B-arbres
+
+## Exemples d'insertion: `6`
+
+![B-arbre d'ordre 1.](figs/barbres_5.svg){width=50%}
+ 
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
+
+# Les B-arbres
+
+## Exemples d'insertion: `6`
+
+![B-arbre d'ordre 1.](figs/barbres_6.svg)
+ 
+. . .
+
+* `6 > 4` on descend à droite;
+* `6 > 5` et on a à la place à droite, on insère.
+
+# Les B-arbres
+
+## Exemples d'insertion: `7`
+
+![B-arbre d'ordre 1.](figs/barbres_6.svg){width=50%}
+ 
+* Comment on insère (1min de réflexion avant de donner une réponse!)?
+
+# Les B-arbres
+
+## Exemples d'insertion: `7`
+
+![B-arbre d'ordre 1.](figs/barbres_7.svg){width=50%}
+ 
+. . .
+
+* `7 > 4` on descend à droite;
+* `7 > 6` mais on a dépassé la capacité;
+* `6` est la médiane de `5, 6, 7`, remonte à la racine;
+* `5` reste à gauche, `7` à droite, mais `6` fait dépasser la capacité de la racine;
+* `4` est la médiane de `2, 4, 6`, `4` remonte, `2` reste à gauche, `6` à droite.
+
+# 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
+
+## Exercice: insérer `5` dans l'arbre d'ordre 2 (3min matrix)
+
+![](figs/barbres_ex2.png)
+
+. . .
+
+![](figs/barbres_ex3.png)
+
+# Les B-arbres
+
+## Exercice: insérer `32, 55, 60` dans l'arbre d'ordre 2 (3min matrix)
+
+![](figs/barbres_ex3.png)
+
+. . .
+
+![](figs/barbres_ex4.png)
+
+# Les B-arbres
+
+## Exercice: insérer `41` dans l'arbre d'ordre 2 (3min matrix)
+
+![](figs/barbres_ex4.png)
+
+. . .
+
+![](figs/barbres_ex5.png)
+
+# Les B-arbres
+
+## Exercice (matrix, 15min)
+
+* 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.
+
+# Les B-arbres
+
+\footnotesize
+
+## Structure de données
+
+* 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;
+
+```
+P_0 | K_1 | P_1 | K_2 | .. | P_i | K_{i+1} | .. | P_{m-1} | K_m | P_m
+```
+
+* `P_0`, ..., `P_m` pointeurs vers enfants;
+* `K_1`, ..., `K_m` les clés.
+* Il y a `m+1` pointeurs mais `m` clés.
+* Comment faire pour gérer l'insertion?
+
+# Les B-arbres
+
+## Faire un dessin de la structure de données (3min matrix)?
+
+. . .
+
+![Structure d'une page de B-arbre d'ordre 2.](figs/barbres_struct.png)
+
+1. On veut un tableau de `P_i, K_i => struct`;
+2. `K_0` va être en "trop";
+3. Pour simplifier l'insertion dans une page, on ajoute un élément de plus.
+
+# Les B-arbres
+
+## 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
+
+## 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";
+* Si la page n'est pas pleine, on a terminé.
+
+# Les B-arbres
+
+## 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
+
+## 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
+
+## L'insertion cas nœud plein, insertion `N`
+
+* 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.
+
+# Les B-arbres
+
+## Pseudo-code structure de données (3min, matrix)?
+
+. . .
+
+```C
+struct page
+    entier ordre, nb
+    element tab[2*ordre + 2]
+```
+
+```C
+struct element
+    entier clé
+    page pg
+```
+
+# Les B-arbres
+
+\footnotesize
+
+## Les fonctions utilitaires (5min matrix)
+
+```C
+booléen est_feuille(page)     // la page est elle une feuille?
+entier position(page, valeur) // à quelle indice on insère?
+booléen est_dans_page(page, valeur) // la valeur est 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
+
+\footnotesize
+
+## Les fonctions utilitaires (5min matrix)
+
+```C
+page nouvelle_page(ordre)  // créer une page
+rien liberer_memoire(page) // libérer tout un arbre!
+```
+. . .
+
+```C
+page nouvelle_page(ordre)
+    page = allouer(page)
+    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)
+```
+
+# Les B-arbres
+
+## Les fonctions (5min matrix)
+
+```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)
+```
+

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!
+

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.