diff --git a/algorithmes/PROPRIETES.md b/algorithmes/PROPRIETES.md
index f6af849..df839df 100644
--- a/algorithmes/PROPRIETES.md
+++ b/algorithmes/PROPRIETES.md
@@ -46,4 +46,5 @@ Si un algorithme met un temps donné pour trier un tableau de taille n, combien
 - Si la **complexité** est **constante**, alors le temps d'execution sera sensiblement toujours le même, peu importe la taille du tableau traité.
 - Si elle est **logarithmique**, alors le temps d'execution augmente très faiblement quand le paramètre croit.
 - **Complexité** **linéaire** : le nombre d'étapes à effectuer va varier en proportion directe de la taille de l'échantillon à traiter : si l'échantillon croît par un facteur de 10000, la complexité sera accrue elle aussi par un facteur de 10000.
+- **Complexité Quadratique** : Dans le cadre du tri par insertion, par exemple, quand on double la taille du tableau, le nombre de comparaisons sera lui multiplié par...4.
 
diff --git a/algorithmes/TRIS.md b/algorithmes/TRIS.md
index 24d0fd3..e38ba3e 100644
--- a/algorithmes/TRIS.md
+++ b/algorithmes/TRIS.md
@@ -105,9 +105,9 @@ Une preuve de correction de l'algorithme est la propriété *p(i)* : "le tableau
 
 Dans le pire des cas (éléments classés par ordre décroissant), la boucle while effectue 2n opérations : chaque tour de boucle for compte pour 2n + 3, répérées n - 1 fois. On a donc (n - 1) (2n + 3).
 
-L'ordre de grandeur est donc de n<sup>2</sup> ou O(n<sup>2</sup> ) : on aura donc un coût **quadratique** dans le pire des cas.
+L'ordre de grandeur est donc de n<sup>2</sup> : on aura donc un coût **quadratique** dans le pire des cas.
 
-Par contre si la liste est déjà triée, le coût est **linéaire**.
+>  Par contre si la liste est déjà triée, le coût est **linéaire**.
 
 [Une excellente méthode pour comprendre](https://www.youtube.com/watch?v=ROalU379l3U)
 
@@ -170,7 +170,7 @@ Il faut montrer l'invariant : à la fin du tour i de la boucle for, les cases ta
 
 - La première boucle for tourne pour i variant de 0 à n-2. Elle s'effectue donc n-2 fois.
 - La seconde boucle s'effectue n-1 - i fois.
-- On a donc n*n en ordre de grandeur, donc la complexité est de type O(n<sup>2</sup>) : **quadratique**
+- On a donc n*n en ordre de grandeur, donc la complexité est : **quadratique**
 
 [Et donc la méthode pour mieux comprendre](https://www.youtube.com/watch?v=Ns4TPTC8whw)
 
diff --git a/representation_base/.DS_Store b/representation_base/.DS_Store
index 843d7c1..09c9866 100644
Binary files a/representation_base/.DS_Store and b/representation_base/.DS_Store differ