diff --git a/slides/cours_10.md b/slides/cours_10.md
index ca2cdc1b99fb910ee0e419a5f0b1465ec2d9722c..37d25f77c091ff9fb70f9f8abda9f067188ae925 100644
--- a/slides/cours_10.md
+++ b/slides/cours_10.md
@@ -263,12 +263,20 @@ non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}
 . . .
 
 ```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
@@ -295,9 +303,22 @@ non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}
 . . .
 
 ```C
-
+int queue_dequeue(queue *fa) {
+    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?
@@ -333,8 +354,9 @@ On défile jusqu'à ce que la file soit vide!
 
 * Données stockées dans un tableau;
 * Tableau de taille connue à la compilation ou pas (reallouable);
-* `head` et `tail` seraient les indices du tableau;
+* `tail` seraient les indices du tableau;
 * `capacity` seraient la capacité maximale;
+* On *enfile* "au bout" du tableau, au défile au début (indice `0`).
 
 . . .
 
@@ -343,7 +365,7 @@ On défile jusqu'à ce que la file soit vide!
 ```C
 typedef struct _queue {
     int *data;
-    int head, tail, capacity;
+    int tail, capacity;
 } queue;
 ```
 
@@ -438,15 +460,97 @@ typedef struct _queue {
 
 
 
+```
+
+# 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;
 ```
 
 
 # File basée sur un tableau (git)
 
 * Créons le squelette et `Makefile` ensemble.
+* On doit choisir: cas simple ou cas compliqué?
 
 . . .
 
 * Créons quelques issues et assignons les!
 
+# 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
+
+## Quelle structure de données?
+
+
+Une liste chaînée bien sûr!
+
+```C
+typedef struct _element { // chaque élément
+    int data;
+    struct _element *next;
+} element;
+typedef element* sorted_list; // la liste
+```
+
+## Fonctionnalités
+
+```C
+// insertion de val
+sorted_list sorted_list_push(sorted_list list, int val);
+// la liste est-elle vide?
+bool is_empty(sorted_list list); // list == NULL
+// extraction de val (il disparaît)
+sorted_list sorted_list_extract(sorted_list list, int val); 
+ // rechercher un élément et le retourner
+element* sorted_list_search(sorted_list list, int val);
+```
+
+# L'insertion
+
+# L'extraction
+
+# La recherche
 
+# Exercice: recherche sans position