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_2.md

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

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)
+```
+