From 2f28ecbcc9cc6d92636a429bcef8c555ced4e75d Mon Sep 17 00:00:00 2001
From: Orestis <orestis.malaspinas@pm.me>
Date: Mon, 8 Nov 2021 16:25:21 +0100
Subject: [PATCH] =?UTF-8?q?ajout=20exercices=20tri=20=C3=A0=20bulles=20et?=
 =?UTF-8?q?=20complexit=C3=A9=20quicksort?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 slides/cours_7.md | 74 +++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 68 insertions(+), 6 deletions(-)

diff --git a/slides/cours_7.md b/slides/cours_7.md
index 435dfc8..854a0db 100644
--- a/slides/cours_7.md
+++ b/slides/cours_7.md
@@ -118,7 +118,7 @@ Compris?
 
 Non c'est normal, faisons un exemple.
 
-# Tri rapide ou quicksort (4/8)
+# Tri rapide ou quicksort (3/8)
 
 Deux variables sont primordiales:
 
@@ -128,7 +128,7 @@ int low, high; // les indices min/max des tableaux à trier
 
 ![Un exemple de quicksort.](figs/quicksort.svg)
 
-# Tri rapide ou quicksort (5/8)
+# Tri rapide ou quicksort (4/8)
 
 Deux variables sont primordiales:
 
@@ -150,7 +150,7 @@ void quicksort(array, low, high) {
 }
 ```
 
-# Tri rapide ou quicksort (6/8)
+# Tri rapide ou quicksort (5/8)
 
 ## Pseudocode: partition
 
@@ -172,7 +172,7 @@ int partition(array, low, high) {
 }
 ```
 
-# Tri rapide ou quicksort (7/8)
+# Tri rapide ou quicksort (6/8)
 
 ## Exercice: implémenter les fonctions `quicksort` et `partition`
 
@@ -193,7 +193,7 @@ void quicksort(int size, int array[size], int first,
 ```
 
 
-# Tri rapide ou quicksort (8/8)
+# Tri rapide ou quicksort (7/8)
 
 \footnotesize
 
@@ -219,6 +219,46 @@ int partition(int size, int array[size], int first, int last) {
 }
 ```
 
+# Tri rapide ou quicksort (8/8)
+
+## Quelle est la complexité du tri rapide?
+
+. . .
+
+* Pire des cas plus: $\mathcal{O}(N^2)$
+    * Quand le pivot sépare toujours le tableau de façon déséquilibrée ($N-1$
+      éléments d'un côté $1$ de l'autre).
+    * $N$ boucles et $N$ comparaisons $\Rightarrow N^2$.
+* Meilleur des cas (toujours le meilleur pivot): $\mathcal{O}(N\cdot \log_2(N))$.
+    * Chaque fois le tableau est séparé en $2$ parties égales.
+    * On a $\log_2(N)$ partitions, et $N$ boucles $\Rightarrow N\cdot
+      \log_2(N)$.
+* En moyenne: $\mathcal{O}(N\cdot \log_2(N))$.
+
+
+# L'algorithme à la main
+
+## Exercice *sur papier*
+
+* Trier par tri rapide le tableau `[5, -2, 1, 3, 10]`
+
+```C
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
 # Tri à bulle (1/4)
 
 ## Algorithme
@@ -266,7 +306,7 @@ void bubble_sort(int size, int array[]) {
 }
 ```
 
-# Tri à bulle (3/4)
+# Tri à bulle (4/4)
 
 ## Quelle est la complexité du tri à bulles?
 
@@ -281,6 +321,28 @@ $$
 $$
 * En moyenne, $\mathcal{O}(N^2)$ ($N^2/2$ comparaisons).
 
+# L'algorithme à la main
+
+## Exercice *sur papier*
+
+* Trier par tri à bulles le tableau `[5, -2, 1, 3, 10]`
+
+```C
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
 # L'algorithme du PPCM *récursif* (1/3)
 
 ## Exemple d'algorithme pour le calcul
-- 
GitLab