diff --git a/algorithmes/DICHOTOMIQUE.md b/algorithmes/DICHOTOMIQUE.md
index fa2ceba..acdf9ec 100644
--- a/algorithmes/DICHOTOMIQUE.md
+++ b/algorithmes/DICHOTOMIQUE.md
@@ -42,4 +42,85 @@ Dans le cas d'une liste **déjà triée**, la recherche dichotomique permet d'am
 
 ![dichotomie](assets/dichotomie.png)
 
-Par Tushe2000 — Template:LoStrangolatore, Domaine public, https://commons.wikimedia.org/w/index.php?curid=39675138
\ No newline at end of file
+> Par Tushe2000 — Template:LoStrangolatore, Domaine public, https://commons.wikimedia.org/w/index.php?curid=39675138
+
+Exercice :
+
+Montrer le nombre d'étapes nécessaires à la réussite de cette recherche.
+
+
+
+-------------
+
+### Complexité
+
+| Taille tableau         | 0    | 1    | 2    | 4    | 8    | 16   | 32   | 64   | 128  | N                |
+| ---------------------- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---------------- |
+| Recherche Séquentielle | 0    | 1    | 2    | 4    | 8    | 16   | 32   | 64   | 128  | N                |
+| Recherche Dichotomique | 0    | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | log<sub>2</sub>N |
+
+- Quel est le pire des cas ici ? Que l'élèment recherché ne soit pas dans le tableau.
+- Le nombre de tours de boucle de la recherche dichotomique est de l'ordrede log<sub>2</sub>(n) où *n* est la taille de la liste.
+
+*Explications*
+
+Qu'est ce que le ***Logarithme***:
+
+pour faire simple, le logarithme en base n - écrit log<sub>n</sub> correspond au nombre de division par n successive pour arriver au nombre 0.
+
+***Exemple :***
+
+Soit un tableau de taille 𝑛.
+
+Si on « coupe » ce tableau en deux parts égales, cela revient à diviser 𝑛 par deux à chaque itération :
+$$
+n_1 = \frac{n}{2} 
+$$
+
+$$
+n_2 = \frac {n_1}{2}
+$$
+
+$$
+n_3 = \frac {n_2}{2}
+$$
+
+
+
+***Important***  : la taille d’un tableau étant forcément un *nombre entier*, 𝑛𝑖 va devenir à un moment ou un autre égal à 1. 
+
+Cela signifiera qu’après avoir divisé 𝑛 par 2 un nombre de fois égal à un certain nombre 𝑎, le tableau ne comportera plus qu’une seule valeur (et par conséquent l’algorithme s’arrête).
+$$
+n_i=1=\frac {n}{2×2×2…×2}=\frac {𝑛}{2𝑎}
+
+$$
+Soit : 𝑎 =log<sub>2</sub>(𝑛)
+
+La recherche dichotomique est donc de complexité ***logarithmique***.
+
+--------
+
+### Terminaison
+
+Pour vérifier que la recherche dichotomique se termine bien, regardons ensemble son code python :
+
+````python
+def dichotomique (tab, x)
+```
+:param res: booléen qui indique si un élèment x se trouve ou non dans le tableau tab
+:param tab: tableau contenant différents élèments déjà triés
+:param x: élèment recherché
+```
+pass
+  
+````
+
+
+
+-----------
+
+Exercices :
+
+- Écrire une fonction *tableau_random*(x, i, j) qui crée un tableau de x nombres aléatoires compris entre i et j
+- Écrire une fonction trier_tableau (tab) qui va trier un tableau par ordre croissant.
+- Écrire la fonction dichotomique (tab, x) qui renvoie True si l'élément x se trouve dans tab, False sinon.
\ No newline at end of file
diff --git a/algorithmes/PARCOURS.md b/algorithmes/PARCOURS.md
index 3b15298..f27c974 100644
--- a/algorithmes/PARCOURS.md
+++ b/algorithmes/PARCOURS.md
@@ -54,9 +54,9 @@ def recherche_max(tab):
   return max
 ```
 
-Complexité ? 
+*Complexité linéaire*
 
-Pourquoi ?
+Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons.
 
 --------
 
@@ -71,9 +71,9 @@ def moyenne(tab):
   return moyenne
 ```
 
-Complexité ?
+*Complexité linéaire*
 
-Pourquoi ?
+Car on parcours toute la liste et donc pour n élèments, on effectuera n comparaisons.
 
 -----------
 
diff --git a/algorithmes/PROPRIETES.md b/algorithmes/PROPRIETES.md
index 3dd8987..7695576 100644
--- a/algorithmes/PROPRIETES.md
+++ b/algorithmes/PROPRIETES.md
@@ -31,7 +31,7 @@ $$
 | Constante     | O(1)             | 10 ns             | 10 ns               | 10 ns                         |
 | Logarithmique | O(log(n))        | 10 ns             | 30 ns               | 60 ns                         |
 | Linéaire      | O(n)             | 100 ns            | 10 μs               | 10 ms                         |
-| Quandratique  | O(n<sup>2</sup>) | 1 μs              | 10 ms               | 2,8 heures                    |
+| Quadratique   | O(n<sup>2</sup>) | 1 μs              | 10 ms               | 2,8 heures                    |