diff --git a/lessons/contenu_cours_4.md b/lessons/contenu_cours_4.md
new file mode 100644
index 0000000000000000000000000000000000000000..ec0a2cadc69a0f85e9ba305e4865421a7dfe0ca3
--- /dev/null
+++ b/lessons/contenu_cours_4.md
@@ -0,0 +1,142 @@
+# Algorithmes et structures de données 2019-20
+
+Contenu du cours 4 du 9.10.2019
+
+*****
+
+## Fonction cube d'un nombre
+
+```C
+ int cube(int x) {
+ return x*x*x;
+ }
+```
+
+## Fonction de parité
+
+```C
+ bool est_pair(int n) {
+ return n%2 == 0;
+ }
+```
+
+## Plus Petit Commun Multiple (PPCM)
+
+- Fonction PPCM: `int ppcm(int n,int m);`
+
+## Plus Grand Commun Diviseur (PGCD)
+
+- Fonction PGCD: `nt pgcd(int n,int m);`
+
+## Paramètres de fonction
+
+- Dans le langage C, les paramètres des fonctions sont toujours passés par copie.
+ Ainsi, la valeur d'une variable passée en paramètre à une fonction n'est pas modifiée,
+ puisque c'est une copie de cette variable qui est passée effectivement à la fonction.
+ Toutes les manipulations effectuées par la fonction le sont donc sur cette copie.
+ Celle-ci est détruite à la fin de l'exécution de la fonction, laissant la variable originelle inchangée.
+
+- Pour que des modifications puissent subsister après l'exécution, on peut procéder de deux manières :
+ 1. en retournant une valeur par la fonction ;
+ 2. en passant en paramètre un pointeur : celui-ci donne accès à une
+ zone mémoire hors de la portée (scope) de la fonction, zone qui
+ peut donc être modifiée durablement.
+
+- Fonction d'incrément
+
+```C
+ void sans_effet(int x) {
+ x++;
+ }
+ void increment(int* x) {
+ (*x)++;
+ }
+
+ void main() {
+ int a = 2;
+ sans_effet(a);
+ printf("a=%d",a); // imprime 2, valeur de a inchangée
+ increment(&a);
+ printf(\"a=%d\",a); // imprime 3
+ }
+```
+
+## Zones d'allocation mémoire
+
+- Un programme utilise deux types de zone mémoire lors de son exécution pour stocker les variables : la pile et le tas.
+- A l'exécution d'un programme, les allocations de variables :
+ 1. sur la pile, sont faites par le système d'exploitation
+ - dans ce cas, on parle de variables statiques
+ 2. sur le tas, sont de la responsabilité de la programmeuse via un appel à la fonction `malloc()`
+ - dans ce cas, on parle de variables dynamiques
+- La désallocation d'une variable statique survient lors de la sortie de sa portée (scope) et est donc automatique.
+- Une variable dynamique doit être explicitement désallouée par la programmeuse avec un appel à la fonction `free()`.
+- Il y a parfois une petite confusion entre la zone mémoire où réside un pointeur et celle où se situe l'espace pointé par le pointeur.
+- Par exemple, l’instruction
+ `char* ptr_ch = malloc(3*sizeof(char));`
+ alloue un espace sur le tas pour 3 caractères, alors que la variable `ptr_ch` est allouée sur la pile.
+
+
+
+## Pseudo-code du tri par sélection
+
+```
+ procedure tri_selection(tableau t[0..n-1])
+ begin
+ for i = 0 to n-2 do
+ ind_min := index_min(t[i..n-1])
+ if t[ind_min] ≠ t[i] then
+ echanger(t[i],t[ind_min])
+ end if
+ end for
+ end tri_selection
+```
+
+## Le tri par insertion
+
+- Algorithme appliqué au tableau: **4 7 6 1 2**
+ - 1ère étape : 4 **7** 6 1 2
+ - trouver la position `pos` de 7 dans le sous-tableau trié à 1 élément : **4**
+ - décaler de 1 les éléments de la position `pos=1` à la fin du sous-tableau
+ - insérer l'élément 7 en position `pos=1`
+
+ - 2ème étape : 4 7 **6** 1 2
+ - trouver la position `pos` de 6 dans le sous-tableau trié à 2 éléments : **4 7**
+ - décaler de 1 les éléments de la position `pos=1` à la fin du sous-tableau
+ - insérer l'élément 6 en position `pos=1`
+
+ - 3ème étape : 4 6 7 **1** 2
+ - trouver la position `pos` de 1 dans le sous-tableau trié à 3 éléments : **4 6 7**
+ - décaler de 1 les éléments de la position `pos=0` à la fin du sous-tableau
+ - insérer l'élément 1 en position `pos=0`
+
+ - 4ème étape : 1 4 6 7 **2**
+ - trouver la position `pos` de 2 dans le sous-tableau trié à 4 éléments : **1 4 6 7**
+ - décaler de 1 les éléments de la position `pos=1` à la fin du sous-tableau
+ - insérer l'élément 2 en position `pos=1`
+
+ - On obtient le tableau trié: **1 2 4 6 7**
+
+## Tri à bulles
+
+- Algorithme appliqué au tableau **4 7 6 2 1**
+ - Principe : on parcours le tableau depuis et on permute les éléments successifs s'ils sont dans le désordre
+ **4 7** 6 2 1
+ 4 **7 6** 2 1
+ 4 6 **7 2** 1
+ 4 6 2 **7 1**
+ 4 6 2 1 7
+A la fin de cette traversée, le plus grand élément se trouve en dernière position.
+
+ - On applique à nouveau ce principe, mais sur le tableau allant de la 1ère à l'avant-dernière case du tableau
+ **4 6** 2 1 7
+ 4 **6 2** 1 7
+ 4 2 **6 1** 7
+ 4 2 1 6 7
+
+ - Et ainsi de suite ...
+
+ - En 4 étapes nécessitant 4, puis 3, puis 2, et finalement 1, opérations de comparaison-échange, on obtient un tableau trié.
+ Donc en 4+3+2+1 = 5**·**4/2 = 10 opérations, on a un tableau trié.
+
+ - Plus généralement, un tableau à N éléments se trie en N(N-1)/2 opérations avec le tri à bulles.
\ No newline at end of file