added lesson 4 version 2019-20

lessons/contenu_cours_4.md

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