ajout cours algo + tris

algorithmes/PROPRIETES.md

@@ -0,0 +1,49 @@
+## Propriétés et caractéristiques d'un algorithme
+
+Il est essentiel, pour un bon algorithme, de posséder certaines propriétés :
+
+- La **terminaison** : Votre algo doit donner un résultat en un **nombre fini d'étapes** et donc ne surtout pas rester coincé dans une boucle.
+
+- La **validation** : Votre algorithme doit amener au résultat attendu, peu importe la situation.
+
+En plus de ces deux propriétés, on peut également citer ***le coût*** ou ***complexité*** :
+
+- en **temps** : le nombre d'opérations nécessaires à son exécution 
+- en **espace** : la quantité d'espace mémoire nécessaire à son exécution
+
+Ici, nous ne nous intéresserons uniquement qu'au **coût en temps, la complexité temporelle.**
+
+### Complexité d'un algorithme
+
+On ne va pas vous demander de chronométrer l'exécution, mais plutôt de trouver **l'ordre de grandeur**.
+
+Il s'agit de différencier les algorithmes selon un type de complexité : on va les grouper par *familles*.
+
+Soit *n* la taille des données d'entrée, on notera la complexité d'un algorithme en fonction de *n* : 
+$$
+O(f(n))
+$$
+
+> On note O pour ***Ordre de grandeur***
+
+| Complexité    | Notation         | Temps pour n = 10 | Temps pour n = 1000 | Temps pour n = 10<sup>6</sup> |
+| ------------- | ---------------- | ----------------- | ------------------- | ----------------------------- |
+| 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                    |
+
+
+
+```
+Pour comprendre la notion de complexité, utilisons l'exemple de tri de tableau : il s'agit d'un des cas les plus récurrents d'utilisation d'un algorithme. On a un tableau, contenant des élèments que l'on devra trier dans un ordre précis.
+
+Si un algorithme met un temps donné pour trier un tableau de taille n, combien de temps lui faudra t-il pour trier un tableau 10 ou 100 fois plus grand ?
+```
+
+- La **complexité d'un algorithme** est une mesure du temps requis par l'algorithme pour accomplir sa tâche, en fonction de la taille des données à traiter.
+- On dira d'un problème qu'il est aussi complexe que le meilleur algorithme connu pour le résoudre.
+- 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.
+