Add insertion sort explanation + corrected grammar (#147)

* corrected mistakes (again)

* Add insertion sort explanation + corrected grammar

* Update Tri_par_insertion and add examples

* add sections on other algorithms

* changed how examples were shown

* Update Tri_par_insertion.md

* typo in example

Co-authored-by: David Leal <[email protected]>
Co-authored-by: Lars Müller <[email protected]>

Author: 3 people

fr/Exemples/.gif/Determinant.gif

@@ -2,32 +2,32 @@
 
 ## Description
 
-Ecrivez une courte desciption de l'algorithme:
+Écrivez une courte description de l'algorithme :
 
 1. Complexité temporelle
 2. Complexité spatiale
 3. Applications possibles
 4. Nom de l'auteur
-5. etc...
+5. ...
 
 ## Étapes
 
 Décrire l'algorithme en étapes concises et compréhensibles.
 
 ## Exemple
 
-Ecrivez le fonctionnement de l'algorithme avec un exemple.
+Écrivez le fonctionnement de l'algorithme avec un exemple.
 
-## Implementation
+## Implémentation
 
-Liens vers des implementation de ce programme dans des languages.
-NOTE: Merci de ne mettre des liens que vers les dossiers de cette organisation.
-Si le programme n'existe pas dans un language, n'hésitez pas à le rajouter!
+Liens vers des implémentations de ce programme dans des langages.
+NOTE : Merci de ne mettre des liens que vers les dossiers de cette organisation.
+Si le programme n'existe pas dans un langage, n'hésitez pas à le rajouter !
 
 ## Vidéo
 
 Lien vers une vidéo qui explique le fonctionnement de l'algorithme.
 
 ## Autres
 
-D'autres informations sont toujours les bienvenues and doivent être inclues dans cette section.
+D'autres informations sont toujours les bienvenues and doivent être incluses dans cette section.

fr/Exemples/.gif/FibonacciNormal.gif

@@ -7,4 +7,6 @@
   * montrer reponse
 * math
   * Basiquement tout
+* tri
+  * basiquement tout
 * Tout le reste

fr/Exemples/.gif/FibonacciRécursif.gif

@@ -4,10 +4,10 @@
 
 ### Principe
 
-* Le filtre de Butterworth est originellement un filtre passe-bas, et c'est le filtre le plus utilisé du fait de son gain extrêment plat dans la zone passe-bande.  
-* L'avantage d'un tel filtre est d'amplifier toute les fréquences voulues de façon uniforme, au lieu d'amplifier certaines fréquences plus que d'autre comme le faisaient les filtres en usage avant sa découverte (les filtres [elliptiques](https://fr.wikipedia.org/wiki/Filtre_elliptique) et [de Tchebychev](https://fr.wikipedia.org/wiki/Filtre_de_Tchebychev)).
+* Le filtre de Butterworth est originellement un filtre passe-bas, et c'est le filtre le plus utilisé du fait de son gain extrêmement plat dans la zone passe-bande.  
+* L'avantage d'un tel filtre est d'amplifier toutes les fréquences voulues de façon uniforme, au lieu d'amplifier certaines fréquences plus que d'autre comme le faisaient les filtres en usage avant sa découverte (les filtres [elliptiques](https://fr.wikipedia.org/wiki/Filtre_elliptique) et [de Tchebychev](https://fr.wikipedia.org/wiki/Filtre_de_Tchebychev)).
 * De plus, Butterworth a prouvé que le filtre passe-bas pouvait être modifié facilement afin de donner des filtres passe-haut, passe-bande ou coupe-bande.
-* La fonction de transfert d'un filtre de Butterworth passe-bas d'ordre $n$ dans le domaine fréquentielle est:
+* La fonction de transfert d'un filtre de Butterworth passe-bas d'ordre $n$ dans le domaine fréquentielle est :
 $$\tag{avec $p_k=\omega_ce^{\frac{j(2k+n-1)\pi}{2n}}$}H(p) = \frac{G_0}{\prod^n_{k=1}(p-p_k)/\omega_c}$$
 
 ### Complexités

fr/Exemples/.gif/FindMax.gif

@@ -4,23 +4,23 @@
 
 ### Principe
 
-* Calculer le déterminant d'un matrice permet de savoir si elle est inversible ou non.  
-* Avoir cette information en elle-même ne sert pas à grand chose mais si cette matrice représente (par exemple) un système d'équation, cela permet de savoir si ce système possède une solution.
+* Calculer le déterminant d'une matrice permet de savoir si elle est inversible ou non.  
+* Avoir cette information en elle-même ne sert pas à grand-chose, mais si cette matrice représente (par exemple) un système d'équation, cela permet de savoir si ce système possède une solution.
 
 ### Complexités
 
 * L'algorithme possède une complexité temporelle de l'ordre de $n!$ (À vérifier).  
-* On utilise une fonction récursive, ce qui est gourmant en terme de mémoire.
+* On utilise une fonction récursive, ce qui est gourmand en termes de mémoire.
 
 ### Applications
 
 * Trouver le déterminant d'une matrice permet de savoir si on peut utiliser la méthode du pivot de Gauss ou pas.
 
 ## Étapes
 
-* Puisque le déterminant n'est défini que pour les matrices carrés, il faut d'abord vérifier que la matrice est carré.
+* Puisque le déterminant n'est défini que pour les matrices carrées, il faut d'abord vérifier que la matrice est carré.
 * Ensuite, nous développons la matrice par rapport à la première ligne.
-* On répète ces étapes à la matrice ainsi développer jusqu'à tomber sur une matrice 2x2, où on applique la formule connue $\bigg(\begin{vmatrix}a&b\\c&d\end{vmatrix}=ad-cb\bigg)$.
+* On répète ces étapes à la matrice ainsi développer jusqu'à tomber sur une matrice 2×2, où on applique la formule connue $\bigg(\begin{vmatrix}a&b\\c&d\end{vmatrix}=ad-cb\bigg)$.
 * De là, on remonte la cascade d'appel en effectuant les calculs.
 
 ## Exemple
@@ -29,12 +29,12 @@ Calculons le déterminant de la matrice $\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{
 
 ### Exemple en vidéo
 
-![Exemple Determinant](../Exemples/.gif/Determinant.gif)
+* [Déterminant](../Exemples/math/Determinant.mp4)
 
 ### Conclusion
 
 Le déterminant de $\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{bmatrix}$ est $0$.
 
-## Implementation
+## Implémentation
 
 * [Python](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/lib.py)

fr/Exemples/.gif/FindMin.gif

@@ -4,16 +4,16 @@
 
 ### Principe
 
-* La suite de Fibonacci est définie mathématiquement de la sorte:
+* La suite de Fibonacci est définie mathématiquement de la sorte :
 $$
 \begin{cases}
 F(0) = 0\\
 F(1) = 1\\
 \forall n \in \natnums / n \ge 2, F(n) = F(n-2) + F(n-1)
 \end{cases}
 $$
-* Cela signifie que chaque terme est la somme des 2 termes précédents, en ayant pour termes de départ 0 et 1.  
-La suite ressemble à ceci:
+* Cela signifie que chaque terme est la somme des deux termes précédents, en ayant pour termes de départ 0 et 1.  
+La suite ressemble à ceci :
 $$0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, \ldots$$
 \
 De nombreux algorithmes existent pour calculer les nombres de la suite, mais nous allons ici nous intéresser à l'implémentation la plus directe.
@@ -35,12 +35,12 @@ Dans notre exemple nous cherchons à calculer F(6), le 7ème terme de la suite.
 
 ### Exemple en vidéo
 
-![Fibonacci normal](../Exemples/.gif/FibonacciNormal.gif)
+* [Fibonacci normal](../Exemples/math/FibonacciNormal.mp4)
 
 ### Conclusion
 
 On a donc $F(6) = 8$
 
-## Implementation
+## Implémentation
 
 * [Python](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)

fr/Exemples/README.md

@@ -4,44 +4,44 @@
 
 ### Principe
 
-* La suite de Fibonacci est définie mathématiquement de la sorte:
+* La suite de Fibonacci est définie mathématiquement de la sorte :
 $$
 \begin{cases}
 F(0) = 0\\
 F(1) = 1\\
 \forall n \in \natnums / n \ge 2, F(n) = F(n-2) + F(n-1)
 \end{cases}
 $$
-* Cela signifie que chaque terme est la somme des 2 termes précédents, en ayant pour termes de départ 0 et 1.  
-La suite ressemble à ceci:
+* Cela signifie que chaque terme est la somme des deux termes précédents, en ayant pour termes de départ 0 et 1.  
+La suite ressemble à ceci :
 $$0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, \ldots$$
 \
 De nombreux algorithmes existent pour calculer les nombres de la suite, mais nous allons ici nous intéresser à l'implémentation la plus immédiate/directe, celle qui est récursive.
 
 ### Complexités
 
-* Cette algorithme n'est pas optimale et prends beaucoup de place et de temps à se terminer.  
+* Cet algorithme n'est pas optimal et prends beaucoup de place et de temps à se terminer.  
 Plus précisement, la complexité temporelle de ce programme est $\phi^n$ ($\phi$ étant le nombre d'or), et sa complexité spatiale est $2^n$.
 
 ## Étapes
 
 * La première étape consiste à appeler $F(n-2)$ et $F(n-1)$.
 * La deuxième consite à appeler $F(n-4)$ et $F(n-3)$ (venant de $F(n-2)$) ainsi que $F(n-3)$ et $F(n-2)$ (venant de $F(n-1)$).
 * Ainsi de suite, jusqu'à appeler $F(1)$ ou $F(0)$, où on peut commencer à remonter la cascade d'appel et à additionner les termes.
-* On a à la fin $F(n)$.
+* On obtient à la fin $F(n)$.
 
 ## Exemple
 
-Dans notre exemple nous cherchons à calculer F(4), le 5ème terme de la suite.
+Dans notre exemple nous cherchons à calculer $F(4)$, le 5ème terme de la suite.
 
 ### Exemple en vidéo
 
-![Fibonnaci récursif](../Exemples/.gif/FibonacciRécursif.gif)
+* [Fibonacci récursif](../Exemples/math/FibonacciRecursif.mp4)
 
 ### Conclusion
 
 On a donc $F(4) = 3$
 
-## Implementation
+## Implémentation
 
 * [Python](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)

fr/Exemples/.mp4/Determinant.mp4 renamed to fr/Exemples/math/Determinant.mp4

@@ -4,7 +4,7 @@
 
 ### Principe
 
-* L'algorithme est directe: on parcours toute la liste de nombre et on retiens le plus grand nombre rencontré jusqu'à ce point.
+* L'algorithme est direct : on parcourt toute la liste de nombre et on retient le plus grand nombre rencontré jusqu'à ce point.
 
 ### Complexités
 
@@ -17,13 +17,13 @@
 
 ### Auteurs
 
-* Au vue de la très grande utilité et de la simplicité de cette algorithme, de nombreuses personnes l'ont très certainement mis au point en même temps.
+* À la vue de la très grande utilité et de la simplicité de cet algorithme, de nombreuses personnes l'ont très certainement mis au point en même temps.
 
 ## Étapes
 
 * En premier lieu, il faut initialiser le maximum. Pour cela, on dit que le maximum est égale au 1er terme de la liste.
-  * Attention! Il ne faut pas prendre pour 1er maximum 0 car si notre liste est composée uniquement de nombres $< 0$, on ne vas pas avoir un maximum correct.
-  * Pour la même raison, il ne faut pas comparer les valeurs absolus des nombres.
+  * Attention ! Il ne faut pas prendre pour 1er maximum 0, car si notre liste est composée uniquement de nombres $< 0$, on ne va pas avoir un maximum correct.
+  * Pour la même raison, il ne faut pas comparer les valeurs absolues des nombres.
 * Ensuite on compare les nombres. Si le 2ème est plus grand que le maximum, il devient le maximum et ainsi de suite, jusqu'à arriver à la fin de la liste.
 
 ## Exemple
@@ -32,4 +32,4 @@ Dans notre exemple, on va prendre la liste $-48,0,8,22,0,31,-38,-15,43,14,22,21,
 
 ### Exemple en vidéo
 
-![Trouver Maximum](../Exemples/.gif/FindMax.gif)
+* [Maximum](../Exemples/math/FindMax.mp4)

fr/Exemples/.mp4/FibonacciNormal.mp4 renamed to fr/Exemples/math/FibonacciNormal.mp4

@@ -4,7 +4,7 @@
 
 ### Principe
 
-* L'algorithme est directe: on parcours toute la liste de nombre et on retiens le plus petit nombre rencontré jusqu'à ce point.
+* L'algorithme est direct : on parcourt toute la liste de nombre et on retient le plus petit nombre rencontré jusqu'à ce point.
 
 ### Complexités
 
@@ -17,13 +17,13 @@
 
 ### Auteurs
 
-* Au vue de la très grande utilité et de la simplicité de cette algorithme, de nombreuses personnes l'ont très certainement mis au point en même temps.
+* À là vue de la très grande utilité et de la simplicité de cet algorithme, de nombreuses personnes l'ont très certainement mis au point en même temps.
 
 ## Étapes
 
 * La première étape est d'initialiser le minimum. Pour cela, on dit qu'il est égale au 1er terme de la liste.
-  * Attention! Il ne faut pas prendre pour 1er minimum 0 car si notre liste est composée uniquement de nombres $> 0$, on ne vas pas avoir un minimum correct.
-  * Pour la même raison, il ne faut pas comparer les valeurs absolus des nombres.
+  * Attention ! Il ne faut pas prendre pour 1er minimum 0, car si notre liste est composée uniquement de nombres $> 0$, on ne va pas avoir un minimum correct.
+  * Pour la même raison, il ne faut pas comparer les valeurs absolues des nombres.
 * Ensuite on compare les nombres. Si le 2ème est plus grand que le minimum, il devient le minimum et ainsi de suite, jusqu'à arriver à la fin de la liste.
 
 ## Exemple
@@ -32,4 +32,4 @@ Dans notre exemple, on va prendre la liste $16,6,2,-14,43,-28,-35,20,-23,25,9,38
 
 ### Exemple en vidéo
 
-![Trouver Minimum](../Exemples/.gif/FindMin.gif)
+* [Minimum](../Exemples/math/FindMin.mp4)

fr/Exemples/.mp4/FibonacciRecursif.mp4 renamed to fr/Exemples/math/FibonacciRecursif.mp4

@@ -0,0 +1,55 @@
+# Tri par insertion
+
+## Description
+
+### Principe
+
+Le principe du tri par insertion est de parcourir la liste de valeurs, en les classant par rapport aux valeurs déjà parcourues.  
+On trie la 2ème valeur par rapport à la 1ère, la 3ème par rapport à la 2ème et la 1ème, etc.
+Ainsi, lorsque l'on compare la n-ième valeur, toutes les valeurs précédentes sont triées.
+
+### Complexités
+
+Lors de l'évaluation des complexités d'un algorithme de tri, il est nécessaire de prendre en compte non seulement le cas général, mais également le meilleur et le pire cas.
+Dans un algorithme de tri, le meilleur cas est celui où la liste est déjà triée, le pire est généralement le cas où la liste est triée "à l'envers" (décroissant si on cherche l'ordre croissant et inversement), le cas général correspond à une liste d'éléments dans le désordre.
+
+* La complexité spatiale d'un tri par insertion est simple et est constante à travers les cas. Il s'agit de la liste des valeurs, car le tri est effectué directement dans la liste, plus une variable qui servira à retenir la valeur que l'on est en train de trier.
+* La complexité temporelle varie beaucoup selon les cas :
+  * Dans le pire des cas, la complexité est en $n^2/2$.
+  * Dans le meilleur cas, la complexité est seulement de $n$.
+  * Finalement, dans le cas général, la complexité est de $n^2/4$.
+* Cet algorithme de tri a pour seuls avantages la très grande facilité d'implémentation, le peu de place mémoire prise et sa rapidité sur les très petites listes ou les listes "presque triées".
+* On préféra utiliser d'autres algorithmes de tri comme le tri par fusion ou le tri rapide dans la grande majorité des cas (cf. leurs explications respectives).
+
+## Étapes
+
+* On commence par comparer la 2ème valeur à la 1ère, et on la place accordement.
+* On compare la 3ème valeur avec la 2ème.
+  * Soit la 3ème valeur est plus grande, auquel cas on passe à la 4eme.
+  * Où alors, elle est plus petite, auquel cas on copie la 2ème valeur à la place de la 3ème, et on compare avec la 1ère.
+    * De là, soit la 1ère est plus petite, et on passe à la 4ème valeur.
+    * Soit, la 1ère est plus grande, et on copie la 1ère à la place de la 2ème, puis on place la valeur que l'on trie à la place de la 1ère.
+* On continue comme cela jusqu'à atteindre la fin de la liste.
+(Je vous conseille de regarder la vidéo pour que le principe soit plus clair.)
+
+## Exemple
+
+Dans notre exemple, on va trier la liste $84, 33, 82, 53, 50, 66, 10, 92, 96, 77, 29$
+
+### Exemple en vidéo
+
+Tri par insertion dans le :
+
+* [cas général](../Exemples/tri/TriInsertionGeneral.mp4)
+* [meilleur cas](../Exemples/tri/TriInsertionMeilleur.mp4)
+* [pire cas](../Exemples/tri/TriInsertionPire.mp4)
+
+## Implémentation
+
+* [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
+
+## Pour aller plus loin
+
+* Dans le meilleur cas, nous n'effectuons qu'une unique comparaison. En effet, le terme comparé et plus grand que le terme juste avant, donc aucune modification n'est à effectuer. (ce qui correspond bien à $n$ opérations)
+* Dans le pire des cas, on doit au contraire "redescendre" tous les termes un par un. On effectue une opération pour remonter le 2ème terme, deux pour le 3ème, etc. On effectue au total un nombre d'opérations de l'ordre de $\Theta(n^2)$.
+  * Bien que le cas moyen soit également un $\Theta(n^2)$, le pire cas effectue plus précisément $\Theta(n^2/2)$ opérations, tandis que le cas moyen en effectue $\Theta(n^2/4)$