diff --git a/Evaluation.md b/Evaluation.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0339298bc42bba36d564f938c9f547c2d83c19f
--- /dev/null
+++ b/Evaluation.md
@@ -0,0 +1,103 @@
+## Etendue de l'étude
+- Nombre de tris
+  - [x] Insertion, Fusion, Rapide et au moins un autre tri sont traités.
+  - [ ] Insertion, Fusion et Rapide sont traités.
+  - [ ] Insertion, Fusion et Rapide ne sont pas tous traités.
+- Type de jeu de test
+  - [x] Aléatoire, Trié, Tri inversé et au moins un autre jeu sont traités.
+  - [ ] Aléatoire, Trié et Tri inversé sont traités.
+  - [ ] Aléatoire, Trié et Tri inversé ne sont pas tous traités.
+
+## Rédaction et analyses
+- Description du problème
+  - [x] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Application
+  - [x] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Environnement de test
+  - [x] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Description de la démarche systématique
+  - [x] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.			
+- Analyse des résultats préalables
+  - [ ] La section est pertinente, succincte et précise.
+  - [x] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Discussion des résultats préalables
+  - [x] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Hypothèse
+  - [x] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Protocole expérimental de vérification de l'hypothèse
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [x] La section n'est pas pertinente.
+- Analyse des résultats expérimentaux
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [x] La section n'est pas pertinente.
+- Discussion des résultats expérimentaux
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [x] La section n'est pas pertinente.
+- Conclusion et travaux futurs
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [x] La section n'est pas pertinente.
+
+## Résultats 	
+- Nombre
+  - [ ] Les tests sont suffisament nombreux pour observer des épiphénomènes
+  - [x] Les tests sont suffisament nombreux pour observer des phénomènes
+  - [ ] Les tests ne sont pas suffisament nombreux pour observer des phénomènes
+- Echantillon
+  - [x] L'échantillon choisi a un bon équilbre entre temps d'exécution et observations
+  - [ ] L'échantillon choisi néglige les temps d'exécution
+  - [ ] L'échantillon choisi néglige les observations
+- Artefacts		
+  - [x] Les observations excluent tout artefacts		
+  - [ ] Certains artefacts, comme des pas d'horloge, sont visibles
+  - [ ]	Seuls des artefacts sont observables
+- Décoration
+  - [x] Les plots contiennent légende et titre
+  - [ ]	Les plots contiennent légende ou titre
+  - [ ]	Les plots ne contiennent ni légende ni titre
+- Lisibilité
+  - [x]	Les plots permettent de lire clairement toutes les séries
+  - [ ]	Les plots permettent de lire clairement la plupart des séries
+  - [ ]	Les plots permettent pas de lire clairement la plupart des séries
+- Echelles
+  - [x] Les échelles sont respectées pour permettre la visualisation et la comparaison des séries entre plots
+  - [ ] Les échelles sont respectées pour permettre la visualisation des séries entre plots
+  - [ ] Les échelles ne sont pas respectées pour permettre la visualisation des séries entre plots
+
+## Hypothèse
+- Originalité
+  - [x] L'hypothèse émise est orginale et trouvée intégralement par l'étudiant.
+  - [ ] L'hypthèse émise est orginale.
+  - [ ] L'hypthèse émise n'est pas originale.
+- Difficulté
+  - [ ] L'hypothèse émise est très difficile à prouver.
+  - [ ]	L'hypothèse émise est difficile à prouver.
+  - [x]	L'hypothèse émise est facile à prouver.
+- Théorie
+  - [ ]	L'analyse de l'hypothèse se confronte à la théorie avec pertinence.
+  - [ ]	L'analyse de l'hypothèse se confronte à la théorie.
+  - [x]	L'analyse de l'hypothèse ne se confronte pas à la théorie.
+
+# Résultat
+
+- Total d'item « Excellent » (1 point) : 14
+- Total d'item « Satisfaisant » (0,5 point: 2
+- Total d'item « Insatisfaisant » (0 point) : 6
+
+- Note sur 22 : 15
diff --git a/README.md b/README.md
index 4a51454c37a9fed7ca4e46f953349f8f23a41449..6792f84da3993cf7c1d5692c77867df5c2183a91 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,3 @@
-
 # P4z : Analyse de performances de différents tris
 
 [Grille d'évaluation P4z](https://docs.google.com/spreadsheets/d/1VXeO91rhy04xa0p8KUhWliFl228utHaDir8MstO5Z-M/edit?usp=sharing
@@ -6,79 +5,153 @@
 
 ## Problème
 
-Description du Problème.
+Le problème est de comprendre comment fonctionnent les algorithmes de tri et de vérifier, en comparant les temps d'exécution et l'utilisation mémoire, lesquelles sont les plus efficaces, dans quelles conditions et de voir si il y a des cas spéciaux dans lesquelles les temps ou l'utilisation mémoire explosent.
+
+Nos paramètres d'étude seront :
+- le temps d'exécution
+- l'utilisation mémoire
 
-Description de tous les paramètres exploratoires du problème
+En fonction des types de tableaux :
+- aléatoires
+- triés croissants
+- triés décroissants
+- constants
+- aléatoires négatifs
+
+Et des types de tris :
+- tri insertion
+- tri fusion
+- tri rapide
+- tri à bulle
 
 ## Dispositif expérimental
 
 ### Application
 
-[code source de l'application](chemin)
+[code source de l'application](./TP3)
 ```
-Description de l'application et des arguments
+main taille maxVal typeTri typeTableau
 ```
+taille : entier : taille du tableau
+
+maxVal : long : valeur maximal prise par les éléments du tableau
+
+typeTri : 1 (insertion) 2 (fusion) 3 (rapide) ou 4 (bulle) : type de tri à utiliser
+
+typeTableau : 1 (aléatoire) 2 (trié croissant) 3 (trié décroissant) 4 (constant) ou 5 (aléatoire négatifs) : type de tableau à utiliser
 
 ### Environnement de test
 
-Description de la plateforme de test
+Les test ont étés effectués sur les serveurs de l'IUT.
 ```
-Extrait pertinent de /proc/cpuinfo
+cat /proc/cpuinfo
+cpu family      : 6
+model           : 2
+model name      : QEMU Virtual CPU version 0.13
+stepping        : 3
+cpu MHz         : 2294.246
+cache size      : 512 KB
+siblings        : 1
+
 ```
 
 ### Description de la démarche systématique
 
-Description de la démarche systématique et de l'espace d'exploration pour chaque paramètres.
+On lance d'abord le script bash, qui nous permet d'avoir un échantillon de plusieurs tests (20) effectués pour chaque types de tris et de tableaux avec des tailles de tableaux aléatoires entre 0 et 50 000. Le nombre de tests s'élève à 100 par types de tableaux, donc 400 en tout.
+Ensuite, on lance le script R de manière à créer nos graphes pour étudier les temps d'exécution et l'utilisation mémoire.
+
+On commence à effectuer quelques tests sur des petits échantillons, pour vérifier que tout fonctionne bien et éviter de perdre du temps, avant de passer à des échantillons plus conséquents pour nos observations.
 
 ```
-Suite des commandes, ou script, à exécuter pour produire les données.
+sh perf.sh | tee perf.dat
+/bin/Rscript perf.R
 ```
 
 ## Résultats préalables
 
 ### Temps d'exécution
 
-| Jeu de test          | Tri par Insertion         | Tri Fusion                | Tri Rapide                |
-|----------------------|---------------------------|---------------------------|---------------------------|
-| Aléatoire            | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) |
-| Trié                 | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) |
-| Tri inversé          | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) |
+![plot](TP3/Graphes/graphesTps.png)
 
 ### Consommation mémoire
 
-| Jeu de test          | Tri par Insertion         | Tri Fusion                | Tri Rapide                |
-|----------------------|---------------------------|---------------------------|---------------------------|
-| Aléatoire            | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) |
-| Trié                 | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) |
-| Tri inversé          | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) |
+![plot](TP3/Graphes/graphesMem.png)
 
 ### Analyse des résultats préalables
 
-Explications précises et succinctes des résultats préalables.
+Temps d'exécution :
+
+On peut déjà observer que le tri insertion prend beaucoup trop de temps à s'effectuer sur des tableau de grandes tailles (4 à 7s) par rapport aux 2 autres tris lorsque les tableaux sont soit aléatoire, soit triés de manière décroissante, cependant, il est assez rapide lorsque le tableau est déjà trié.
+
+Le tri fusion est assez polyvalent est assez rapide dans chacun des cas.
+
+Le tri rapide est assez rapide lorsqu'il s'agit de trier un tableau aléatoire, cependant le temps d'exécution explose lorsqu'il doit trier un tableau qui est déjà trié (jusqu'à plus de 10s). On observe également un temps d'exécution plus élevé que les 2 autres types de tris quand le tableau est trié de manière décroissante (jusqu'à 4s).
+
+Utilisation mémoire :
+
+On observe que, peu importe le type de tableau, l'utilisation mémoire augmente de manière assez linéaire pour tous les types de tris, cependant, pour chaque type de tris ils n'augmentent pas à la même vitesse: le tri insertion n'utilise que très peu de mémoire par rapport au tri rapide, qui lui est assez moyen, et au tri fusion, qui lui utilise énormément du mémoire, dû à la création de nouveaux tableaux à chaque itération.
 
 ### Discussion des résultats préalables
 
-Explications précises et succinctes des limites des résultats
-préalables et ce qu'ils ne permettent pas de vérifier.
+Dans certains cas, les courbes sont beaucoup trop proches, et parfois les différences sont impossible à trouver, comme par exemple quand le tableau est déjà trié pour les tris insertion et fusion et dont le temps d'exécution est à 0.
+
+Même si dans la plupart des cas on peut trouver un "pire" et un "meilleur" tri, au niveau du temps d'exécution, il reste des cas dans lesquels cette différence ne se trouve pas comme les courbes se confondent.
 
 ## Etude approfondie
 
 ### Hypothèse
 
-Expression précise et succincte d'une hypothèse.
+Réduire la consommation de mémoire pourrait permettre d'augmenter la vitesse des tris.
+
+Voyons le cas du tri fusion car c'est le type de tri dont ma version de base utilise le plus de mémoire.
+
+Nos paramètres d'étude seront :
+- le temps d'exécution
+- l'utilisation mémoire
+
+En fonction des types de tableaux :
+- aléatoires
+- triés croissants
+- triés décroissants
+- constants
+- aléatoires négatifs
+
+Les tests seront effectués sur 2 types de tri :
+- tri fusion
+- tri fusion dont l'utilisation mémoire est optimisée
 
 ### Protocole expérimental de vérification de l'hypothèse
 
-Expression précise et succincte du protocole.
+On lance d'abord le script bash, qui nous permet d'avoir un échantillon de plusieurs tests (50) effectués uniquement sur le tri fusion et sa version optimisée et différents types de tableaux avec des tailles aléatoires entre 0 et 1 000 000. On a donc 250 test par tableaux donc 500 en tout. On effectue plus de tests sur ces 2 tableaux comparé à la 1ère partie car le tri fusion est le plus rapide, on peut alors se permettre d'effectuer des tests plus conséquents de manière à mieux analyser les graphes.
+Ensuite, on lance le script R de manière à créer nos graphes pour étudier les temps d'exécution et l'utilisation mémoire.
 
 ```
-Suite des commandes, ou script, à exécuter pour produire les données.
+sh perfHyp.sh | tee perfHyp.dat
+/bin/Rscript perfHyp.R
 ```
 
 ### Résultats expérimentaux
 
+### Temps d'exécution
+
+![plot](TP3/Graphes/graphesTpsHyp.png)
+
+### Consommation mémoire
+
+![plot](TP3/Graphes/graphesMemHyp.png)
+
 ### Analyse des résultats expérimentaux
 
+On peut observer que même si l'utilisation mémoire diminue drastiquement, le temps d'exécution bouge très peu.
+
+On peut observer de très légères diminutions de temps d'exécution, on peut voir que dans la plupart des cas, quand le tableau à une taille maximale, le tri optimisé est un peu plus rapide que l'autre. Par exemple, pour le tableau constant la version normale est environ à 1s et l'optimisé atteint à peine légèrement au-dessus de 0.75s; pour un tableau trié,la version normale atteint presque 1.5s et la version optimisée est à 1.25; ou encore le tableau trié dans l'ordre décroissant, la version optimisée est plus rapide d'environ 0.25s
+
 ### Discussion des résultats expérimentaux
 
+On se retrouve avec différences infimes entre les 2 types de tris ce qui rend les observations assez difficiles. De même, il pourrait exister une meilleur version de notre tri fusion qui pourrait permettre d'observer des différences plus significatives.
+
 ## Conclusion et travaux futurs
+
+On peut en conclure que diminuer l'utilisation de la mémoire permet effectivement de diminuer le temps d'exécution. Cependant, la diminution de l'utilisation mémoire n'est pas proportionnelle au temps d'exécution, on observe un diminution énorme d'utilisation mémoire pour seulement jusqu'à 0.25s de temps d'exécution gagné.
+
+On peut alors penser que l'utilisation de tableaux beaucoup plus gros permettrait de voir une plus grosse différence. De la même manière, les mêmes essais pourrait être effectués sur d'autres types types de tris pour espérer voir plus de différences, ou bien s'il existe une meilleur manière d'optimiser le tri fusion.
diff --git a/TP1/function.c b/TP1/function.c
new file mode 100644
index 0000000000000000000000000000000000000000..61c439b2822f7c40a2158f8ffe359e54b91e6f93
--- /dev/null
+++ b/TP1/function.c
@@ -0,0 +1,29 @@
+#include "function.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void afficheTab(long tabAAffiche[], size_t tabTaille){
+  printf("[ ");
+  for(size_t i=0; i<tabTaille; i++){
+    if(i==tabTaille-1){
+      printf("%ld", tabAAffiche[i]);
+    }
+    else{
+      printf("%ld, ", tabAAffiche[i]);
+    }
+  }
+  printf(" ]\n");
+}
+
+void genTabAlea(long tabARemplir[], size_t tailleTab) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(10);
+  }
+}
diff --git a/TP1/function.h b/TP1/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd76e310526210110bc6a633c088eb1688c02c09
--- /dev/null
+++ b/TP1/function.h
@@ -0,0 +1,8 @@
+#define _function_h
+#include <stdio.h>
+
+//Procédure d'affichage d'un tableau passé en paramètre
+void afficheTab(long tabAAffiche[], size_t tabTaille);
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires
+void genTabAlea(long tabARemplir[], size_t tailleTab);
diff --git a/TP1/main.c b/TP1/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..bf5e0fcf84649f278d9c64f1165ce7e36250c588
--- /dev/null
+++ b/TP1/main.c
@@ -0,0 +1,35 @@
+#include "tri_fusion.h"
+#include "tri_rapide.h"
+#include "tri_insertion.h"
+#include "function.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char const *argv[]) {
+
+  long tableauBis[20];
+  memset(tableauBis, 0, 20*sizeof(long));
+  printf("--- Tableau initial insertion ---\n");
+  genTabAlea(tableauBis,20);
+  afficheTab(tableauBis,20);
+  tri_insertion(tableauBis,20);
+  afficheTab(tableauBis,20);
+
+  printf("\n\n");
+
+  /*printf("--- Tableau initial fusion ---\n");
+  genTabAlea(tableauBis,20);
+  afficheTab(tableauBis,20);
+  triFusion(tableauBis,20);
+  afficheTab(tableauBis,20);*/
+
+  printf("\n\n");
+
+  /*printf("--- Tableau initial rapide ---\n");
+  genTabAlea(tableauBis,20);
+  afficheTab(tableauBis,20);
+  triRapide(tableauBis,20);
+  afficheTab(tableauBis,20);*/
+
+  return 0;
+}
diff --git a/TP1/makefile b/TP1/makefile
new file mode 100644
index 0000000000000000000000000000000000000000..e97678c5eb0b86d8ee8d691d976edd1669a9037e
--- /dev/null
+++ b/TP1/makefile
@@ -0,0 +1,17 @@
+all: main
+main: main.c tri_fusion.o tri_rapide.o tri_insertion.o function.o
+	gcc -Wall -o main tri_fusion.o tri_rapide.o tri_insertion.o function.o main.c
+
+tri_fusion.o: tri_fusion.h tri_fusion.c
+	gcc -Wall -c tri_fusion.c
+
+tri_rapide.o: tri_rapide.h tri_rapide.c
+	gcc -Wall -c tri_rapide.c
+
+tri_insertion.o: tri_insertion.h tri_insertion.c
+	gcc -c tri_insertion.c -Wall
+
+function.o: function.h function.c
+	gcc -c function.c -Wall
+clean:
+	rm *.o main
diff --git a/TP1/tri_fusion.c b/TP1/tri_fusion.c
new file mode 100644
index 0000000000000000000000000000000000000000..494be4d0d44859fa7d56150435682110e4cdf8e7
--- /dev/null
+++ b/TP1/tri_fusion.c
@@ -0,0 +1,60 @@
+#include "tri_fusion.h"
+#include "function.h"
+
+void sousTriFusion(long tab[], size_t p, size_t r){
+  if(p < r - 1){
+    size_t q = (p + r)/2;
+    sousTriFusion(tab, p, q);
+    sousTriFusion(tab, q, r);
+    fusion(tab, p, q, r);
+  }
+}
+
+void fusion(long tab[], size_t p, size_t q, size_t r){
+  size_t n1 = q - p;
+  size_t n2 = r - q;
+
+  long tabG[n1];
+  long tabD[n2];
+  memset(tabD, 0, n1*sizeof(long));
+  memset(tabG, 0, n2*sizeof(long));
+  size_t j = 0;
+  for(size_t i = p; i < q; i++) {
+    tabG[j] = tab[i];
+    j++;
+  }
+  j = 0;
+  for(size_t i = q; i < r; i++){
+    tabD[j] = tab[i];
+    j++;
+  }
+
+  size_t indG = 0;
+  size_t indD = 0;
+  size_t i = p;
+
+  while(i < r){
+    if(indG == n1){
+      tab[i] = tabD[indD];
+      indD++;
+    }
+    else if(indD == n2){
+      tab[i] = tabG[indG];
+      indG++;
+    }
+    else if(tabG[indG] < tabD[indD]){
+      tab[i] = tabG[indG];
+      indG++;
+    }
+    else{
+      tab[i] = tabD[indD];
+      indD++;
+    }
+    i++;
+  }
+}
+
+void triFusion(long tab[], size_t taille){
+  printf("--- Lancement d'un tri fusion ! ---\n");
+  sousTriFusion(tab, 0, taille);
+}
diff --git a/TP1/tri_fusion.h b/TP1/tri_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..39c647103d42df0bc59c3ea55877c87962709bb6
--- /dev/null
+++ b/TP1/tri_fusion.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void sousTriFusion(long tab[], size_t p, size_t r);
+void fusion(long tab[], size_t p, size_t q, size_t r);
+void triFusion(long tab[], size_t taille);
diff --git a/TP1/tri_insertion.c b/TP1/tri_insertion.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d79323893704574c8a8e22343c990a08fe58348
--- /dev/null
+++ b/TP1/tri_insertion.c
@@ -0,0 +1,18 @@
+#include "tri_insertion.h"
+#include "function.h"
+
+void tri_insertion(long tabInit[], size_t tailleTab) {
+  printf("--- Lancement d'un tri insertion ! ---\n");
+
+  for(size_t i=1; i<tailleTab; i++) {
+    long clef = tabInit[i];
+    int j=i-1;
+
+    while(j >= 0 && tabInit[j]>clef) {
+      tabInit[j+1]=tabInit[j];
+      j=j-1;
+    }
+
+    tabInit[j+1]=clef;
+  }
+}
diff --git a/TP1/tri_insertion.h b/TP1/tri_insertion.h
new file mode 100644
index 0000000000000000000000000000000000000000..809c1825803e514d9feee69416af644352b0613f
--- /dev/null
+++ b/TP1/tri_insertion.h
@@ -0,0 +1,4 @@
+#define _tri_insertion_h
+#include <stdio.h>
+
+void tri_insertion(long tabInit[], size_t tailleTab);
diff --git a/TP1/tri_rapide.c b/TP1/tri_rapide.c
new file mode 100644
index 0000000000000000000000000000000000000000..e87f0e2c459369bb85751fa4cd7f022c6d865ccb
--- /dev/null
+++ b/TP1/tri_rapide.c
@@ -0,0 +1,37 @@
+#include "tri_rapide.h"
+#include "function.h"
+
+void sousTriRapide(long tab[], size_t p, size_t r){
+  size_t max = 0; max--;
+  if(r-1 != max){
+    if(p < r-1 ){
+      size_t q = partition(tab, p, r);
+      sousTriRapide(tab, p, q);
+      sousTriRapide(tab, q+1, r);
+    }
+  }
+}
+
+int partition(long tab[], size_t p, size_t r){
+  long pivot = tab[r - 1];
+  size_t i = p;
+
+  for(size_t j = p; j <= (r - 2); j++ ){
+    if(tab[j] <= pivot){
+      long temp = tab[j];
+      tab[j] = tab[i];
+      tab[i] = temp;
+      i++;
+    }
+  }
+  long temp = tab[i];
+  tab[i] = tab[r-1];
+  tab[r-1] = temp;
+  return i;
+
+}
+
+void triRapide(long tab[], size_t taille){
+  printf("--- Lancement d'un tri rapide ! ---\n");
+  sousTriRapide(tab, 0, taille);
+}
diff --git a/TP1/tri_rapide.h b/TP1/tri_rapide.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c3ddeb8aad77b4cef2ba48eddec5a0d9c895f8c
--- /dev/null
+++ b/TP1/tri_rapide.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void sousTriRapide(long tab[], size_t p, size_t r);
+int partition(long tab[], size_t p, size_t r);
+void triRapide(long tab[], size_t taille);
diff --git a/TP2/function.c b/TP2/function.c
new file mode 100644
index 0000000000000000000000000000000000000000..903ba5ea244ffa86856f94fba473807b17cdc27d
--- /dev/null
+++ b/TP2/function.c
@@ -0,0 +1,81 @@
+#include "function.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void afficheTab(long tabAAffiche[], size_t tabTaille){
+  printf("[ ");
+  for(size_t i=0; i<tabTaille; i++){
+    if(i==tabTaille-1){
+      printf("%ld", tabAAffiche[i]);
+    }
+    else{
+      printf("%ld, ", tabAAffiche[i]);
+    }
+  }
+  printf(" ]\n");
+}
+
+void genTabAlea(long tabARemplir[], size_t tailleTab) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(100);
+  }
+}
+
+void compter(long* i){
+  *i += 1;
+}
+
+void genTabConst(long tabARemplir[], size_t tailleTab) {
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=1;
+  }
+}
+
+void genTabNeg(long tabARemplir[], size_t tailleTab) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(10)*-1;
+  }
+}
+
+void genTabDecroi(long tabARemplir[], size_t tailleTab) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(1000);
+  }
+  qsort( tabARemplir, tailleTab, sizeof(long), longComparator );
+}
+int longComparator ( const void * first, const void * second ) {
+  return ( *(long*)second - *(long*)first );
+}
+
+void affiche_infos(struct compteur cpt){
+  printf("nombre de comparaisons : %ld\n", cpt.comparaison);
+  printf("nombre d'écritures : %ld\n", cpt.ecriture);
+  printf("nombre de fusions : %ld\n", cpt.fusion);
+  printf("nombre de partitions : %ld\n", cpt.partition);
+}
+
+void calc_chrono(clock_t chronoDebut, clock_t chronoFin){
+  clock_t nbTicks = chronoFin-chronoDebut;
+  float secondes=(float)nbTicks/CLOCKS_PER_SEC;
+  float millisecondes=(float)nbTicks * 1000/ CLOCKS_PER_SEC;
+  printf( "Tri réalisé en %f sec, ou %f millisec. (%ld ticks)\n", secondes, millisecondes, nbTicks );
+}
diff --git a/TP2/function.h b/TP2/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b7aa2de53af676b0274e59284c798e2408c5927
--- /dev/null
+++ b/TP2/function.h
@@ -0,0 +1,35 @@
+#define _function_h
+#include <stdio.h>
+#include <time.h>
+
+struct compteur{
+  long comparaison;
+  long ecriture;
+  long fusion;
+  long partition;
+};
+
+//Procédure d'affichage d'un tableau passé en paramètre
+void afficheTab(long tabAAffiche[], size_t tabTaille);
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires
+void genTabAlea(long tabARemplir[], size_t tailleTab);
+
+//Remplis le tableau passé en paramètre avec des 1
+void genTabConst(long tabARemplir[], size_t tailleTab);
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires négatives
+void genTabNeg(long tabARemplir[], size_t tailleTab);
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires tiré dans l'ordre décroissant
+void genTabDecroi(long tabARemplir[], size_t tailleTab);
+int longComparator( const void * first, const void * second );
+
+//compte le nombre de comparaisons
+void compter(long* i);
+
+//affiche les infos de compteur
+void affiche_infos(struct compteur cpt);
+
+//calcule le temps écoulé
+void calc_chrono(clock_t chronoDebut, clock_t chronoFin);
diff --git a/TP2/main.c b/TP2/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..19b5bd37584e425a5d0576afc3d3b46fff75c283
--- /dev/null
+++ b/TP2/main.c
@@ -0,0 +1,53 @@
+#include "tri_fusion.h"
+#include "tri_rapide.h"
+#include "tri_insertion.h"
+#include "function.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char const *argv[]) {
+
+  int tailleTab = 20;
+  if(argc > 1){
+    tailleTab = atoi(argv[1]);
+  }
+  printf("Taille du tableau : %d\n", tailleTab);
+  long tableauBis[tailleTab];
+  memset(tableauBis, 0, tailleTab*sizeof(long));
+
+  /*long tab[5] = {3,2,5,1,4};
+  afficheTab(tab,5);
+  triRapide(tab,5);
+  afficheTab(tab,5);*/
+
+  printf("--- Tableau initial ---\n");
+  //genTabAlea(tableauBis,tailleTab);
+  //genTabConst(tableauBis,tailleTab);
+  //genTabNeg(tableauBis,tailleTab);
+  genTabDecroi(tableauBis,tailleTab);
+  //afficheTab(tableauBis,tailleTab);
+
+
+  tri_insertion(tableauBis,tailleTab);
+  //afficheTab(tableauBis,tailleTab);
+
+  printf("\n\n");
+
+  //genTabAlea(tableauBis,tailleTab);
+  //genTabConst(tableauBis,tailleTab);
+  //genTabNeg(tableauBis,tailleTab);
+  genTabDecroi(tableauBis,tailleTab);
+  triFusion(tableauBis,tailleTab);
+  //afficheTab(tableauBis,tailleTab);
+
+  printf("\n\n");
+
+  //genTabAlea(tableauBis,tailleTab);
+  //genTabConst(tableauBis,tailleTab);
+  //genTabNeg(tableauBis,tailleTab);
+  genTabDecroi(tableauBis,tailleTab);
+  triRapide(tableauBis,tailleTab);
+  //afficheTab(tableauBis,tailleTab);
+
+  return 0;
+}
diff --git a/TP2/makefile b/TP2/makefile
new file mode 100644
index 0000000000000000000000000000000000000000..e97678c5eb0b86d8ee8d691d976edd1669a9037e
--- /dev/null
+++ b/TP2/makefile
@@ -0,0 +1,17 @@
+all: main
+main: main.c tri_fusion.o tri_rapide.o tri_insertion.o function.o
+	gcc -Wall -o main tri_fusion.o tri_rapide.o tri_insertion.o function.o main.c
+
+tri_fusion.o: tri_fusion.h tri_fusion.c
+	gcc -Wall -c tri_fusion.c
+
+tri_rapide.o: tri_rapide.h tri_rapide.c
+	gcc -Wall -c tri_rapide.c
+
+tri_insertion.o: tri_insertion.h tri_insertion.c
+	gcc -c tri_insertion.c -Wall
+
+function.o: function.h function.c
+	gcc -c function.c -Wall
+clean:
+	rm *.o main
diff --git a/TP2/tri_fusion.c b/TP2/tri_fusion.c
new file mode 100644
index 0000000000000000000000000000000000000000..5426590c883f89180bb71560650890e9271e0d94
--- /dev/null
+++ b/TP2/tri_fusion.c
@@ -0,0 +1,75 @@
+#include "tri_fusion.h"
+#include "function.h"
+
+struct compteur cptf;
+clock_t chronoDebut;
+clock_t chronoFin;
+
+void sousTriFusion(long tab[], size_t p, size_t r){
+  if(p < r - 1){
+    size_t q = (p + r)/2;
+    sousTriFusion(tab, p, q);
+    sousTriFusion(tab, q, r);
+    fusion(tab, p, q, r);
+    compter(&cptf.fusion);
+  }
+}
+
+void fusion(long tab[], size_t p, size_t q, size_t r){
+  size_t n1 = q - p;
+  size_t n2 = r - q;
+
+  long tabG[n1];
+  long tabD[n2];
+  //memset(tabD, 0, n1*sizeof(long));
+  //memset(tabG, 0, n2*sizeof(long));
+  size_t j = 0;
+  for(size_t i = p; i < q; i++) {
+    tabG[j] = tab[i];
+    j++;
+    compter(&cptf.ecriture);
+  }
+  j = 0;
+  for(size_t i = q; i < r; i++){
+    tabD[j] = tab[i];
+    j++;
+    compter(&cptf.ecriture);
+  }
+
+  size_t indG = 0;
+  size_t indD = 0;
+  size_t i = p;
+
+  while(i < r){
+    if(indG == n1){
+      compter(&cptf.comparaison);
+      tab[i] = tabD[indD];
+      indD++;
+    }
+    else if(indD == n2){
+      compter(&cptf.comparaison);
+      tab[i] = tabG[indG];
+      indG++;
+    }
+    else if(tabG[indG] < tabD[indD]){
+      compter(&cptf.comparaison);
+      tab[i] = tabG[indG];
+      indG++;
+    }
+    else{
+      tab[i] = tabD[indD];
+      indD++;
+    }
+    i++;
+    compter(&cptf.ecriture);
+  }
+}
+
+void triFusion(long tab[], size_t taille){
+  printf("--- Lancement d'un tri fusion ! ---\n");
+  chronoDebut= clock();
+  sousTriFusion(tab, 0, taille);
+  chronoFin= clock();
+  calc_chrono(chronoDebut,chronoFin);
+  affiche_infos(cptf);
+}
diff --git a/TP2/tri_fusion.h b/TP2/tri_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..39c647103d42df0bc59c3ea55877c87962709bb6
--- /dev/null
+++ b/TP2/tri_fusion.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void sousTriFusion(long tab[], size_t p, size_t r);
+void fusion(long tab[], size_t p, size_t q, size_t r);
+void triFusion(long tab[], size_t taille);
diff --git a/TP2/tri_insertion.c b/TP2/tri_insertion.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c51238f2291d1ed92516586a33415db259d2862
--- /dev/null
+++ b/TP2/tri_insertion.c
@@ -0,0 +1,36 @@
+#include "tri_insertion.h"
+#include "function.h"
+#include <time.h>
+
+//compter malloc; compter allocations, nb fusions et partition
+//comparer taille tableau et temps de traitement
+//trouver tableaux qui cassent (extrèmes/particulier)
+
+clock_t chronoDebut;
+clock_t chronoFin;
+
+struct compteur cpt;
+
+void tri_insertion(long tabInit[], size_t tailleTab) {
+  printf("--- Lancement d'un tri insertion ! ---\n");
+
+  chronoDebut= clock();
+
+  for(size_t i=1; i<tailleTab; i++) {
+    long clef = tabInit[i];
+    int j=i-1;
+    compter(&cpt.comparaison);
+    while(j >= 0 && tabInit[j]>clef) {
+      tabInit[j+1]=tabInit[j];
+      compter(&cpt.ecriture);
+      j=j-1;
+    }
+
+    tabInit[j+1]=clef;
+    compter(&cpt.ecriture);
+  }
+  chronoFin= clock();
+  calc_chrono(chronoDebut,chronoFin);
+  affiche_infos(cpt);
+  printf("--- Fin du tri insertion ! ---\n");
+}
diff --git a/TP2/tri_insertion.h b/TP2/tri_insertion.h
new file mode 100644
index 0000000000000000000000000000000000000000..809c1825803e514d9feee69416af644352b0613f
--- /dev/null
+++ b/TP2/tri_insertion.h
@@ -0,0 +1,4 @@
+#define _tri_insertion_h
+#include <stdio.h>
+
+void tri_insertion(long tabInit[], size_t tailleTab);
diff --git a/TP2/tri_rapide.c b/TP2/tri_rapide.c
new file mode 100644
index 0000000000000000000000000000000000000000..3de51f4377dd13902246bcfc1ad8871f33dd0ac6
--- /dev/null
+++ b/TP2/tri_rapide.c
@@ -0,0 +1,51 @@
+#include "tri_rapide.h"
+#include "function.h"
+
+struct compteur cptr;
+clock_t chronoDebut;
+clock_t chronoFin;
+
+void sousTriRapide(long tab[], size_t p, size_t r){
+  size_t max = 0; max--;
+  if(r-1 != max){
+    if(p < r-1 ){
+      size_t q = partition(tab, p, r);
+      compter(&cptr.partition);
+      sousTriRapide(tab, p, q);
+      sousTriRapide(tab, q+1, r);
+    }
+  }
+}
+
+int partition(long tab[], size_t p, size_t r){
+  long pivot = tab[r - 1];
+  size_t i = p;
+
+  for(size_t j = p; j <= (r - 2); j++ ){
+    if(tab[j] <= pivot){
+      compter(&cptr.comparaison);
+      long temp = tab[j];
+      tab[j] = tab[i];
+      compter(&cptr.ecriture);
+      tab[i] = temp;
+      compter(&cptr.ecriture);
+      i++;
+    }
+  }
+  long temp = tab[i];
+  tab[i] = tab[r-1];
+  compter(&cptr.ecriture);
+  tab[r-1] = temp;
+  compter(&cptr.ecriture);
+  return i;
+
+}
+
+void triRapide(long tab[], size_t taille){
+  printf("--- Lancement d'un tri rapide ! ---\n");
+  chronoDebut= clock();
+  sousTriRapide(tab, 0, taille);
+  chronoFin= clock();
+  calc_chrono(chronoDebut,chronoFin);
+  affiche_infos(cptr);
+}
diff --git a/TP2/tri_rapide.h b/TP2/tri_rapide.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c3ddeb8aad77b4cef2ba48eddec5a0d9c895f8c
--- /dev/null
+++ b/TP2/tri_rapide.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void sousTriRapide(long tab[], size_t p, size_t r);
+int partition(long tab[], size_t p, size_t r);
+void triRapide(long tab[], size_t taille);
diff --git a/TP3/Graphes/graphes.png b/TP3/Graphes/graphes.png
new file mode 100644
index 0000000000000000000000000000000000000000..2d8a1b9f7847c4fc07a46f57e21e5ea2ff44cf3c
Binary files /dev/null and b/TP3/Graphes/graphes.png differ
diff --git a/TP3/Graphes/graphesMem.png b/TP3/Graphes/graphesMem.png
new file mode 100644
index 0000000000000000000000000000000000000000..13205e8883d6353e6000dedf31dee394bbd07f16
Binary files /dev/null and b/TP3/Graphes/graphesMem.png differ
diff --git a/TP3/Graphes/graphesMemHyp.png b/TP3/Graphes/graphesMemHyp.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce95f261a569af82bcaebf7d6ed256ae5eca54b7
Binary files /dev/null and b/TP3/Graphes/graphesMemHyp.png differ
diff --git a/TP3/Graphes/graphesTps.png b/TP3/Graphes/graphesTps.png
new file mode 100644
index 0000000000000000000000000000000000000000..1a62e6e4fcee5cd32ded6888cf56d8b5ad8850c0
Binary files /dev/null and b/TP3/Graphes/graphesTps.png differ
diff --git a/TP3/Graphes/graphesTpsHyp.png b/TP3/Graphes/graphesTpsHyp.png
new file mode 100644
index 0000000000000000000000000000000000000000..11f809cb197b7001f837b8a88f03e4dcf92ea421
Binary files /dev/null and b/TP3/Graphes/graphesTpsHyp.png differ
diff --git a/TP3/function.c b/TP3/function.c
new file mode 100644
index 0000000000000000000000000000000000000000..fc12a7e2286a1a2ac236becc699e3d3e41a1168b
--- /dev/null
+++ b/TP3/function.c
@@ -0,0 +1,92 @@
+#include "function.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#define MAXVAL 100000
+
+void afficheTab(long tabAAffiche[], size_t tabTaille){
+  printf("[ ");
+  for(size_t i=0; i<tabTaille; i++){
+    if(i==tabTaille-1){
+      printf("%ld", tabAAffiche[i]);
+    }
+    else{
+      printf("%ld, ", tabAAffiche[i]);
+    }
+  }
+  printf(" ]\n");
+}
+
+void genTabAlea(long tabARemplir[], size_t tailleTab, int maxVal) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(maxVal);
+  }
+}
+
+void compter(long* i){
+  *i += 1;
+}
+
+void genTabConst(long tabARemplir[], size_t tailleTab) {
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=1;
+  }
+}
+
+void genTabNeg(long tabARemplir[], size_t tailleTab, int maxVal) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(maxVal)*-1;
+  }
+}
+
+void genTabDecroi(long tabARemplir[], size_t tailleTab, int maxVal) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(maxVal);
+  }
+  qsort( tabARemplir, tailleTab, sizeof(long), longComparatorDecroi );
+}
+int longComparatorDecroi ( const void * first, const void * second ) {
+  return ( *(long*)second - *(long*)first );
+}
+
+void genTabCroi(long tabARemplir[], size_t tailleTab, int maxVal) {
+  int rand_is_seeded = 0;
+    if(!rand_is_seeded)
+    {
+        srand(time(NULL));
+        rand_is_seeded = 1;
+    }
+  for(size_t i=0; i<tailleTab; i++){
+    tabARemplir[i]=rand()%(maxVal);
+  }
+  qsort( tabARemplir, tailleTab, sizeof(long), longComparatorCroi );
+}
+int longComparatorCroi ( const void * first, const void * second ) {
+  return ( *(long*)first - *(long*)second );
+}
+
+
+void affiche_infos(struct compteur cpt){
+  printf("nombre de comparaisons : %ld\n", cpt.comparaison);
+  printf("nombre d'écritures : %ld\n", cpt.ecriture);
+  printf("nombre de fusions : %ld\n", cpt.fusion);
+  printf("nombre de partitions : %ld\n", cpt.partition);
+}
diff --git a/TP3/function.h b/TP3/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d548b55c21951e189492414157ff0e275486fa4
--- /dev/null
+++ b/TP3/function.h
@@ -0,0 +1,36 @@
+#define _function_h
+#include <stdio.h>
+#include <time.h>
+
+struct compteur{
+  long comparaison;
+  long ecriture;
+  long fusion;
+  long partition;
+};
+
+//Procédure d'affichage d'un tableau passé en paramètre
+void afficheTab(long tabAAffiche[], size_t tabTaille);
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires
+void genTabAlea(long tabARemplir[], size_t tailleTab, int maxVal);
+
+//Remplis le tableau passé en paramètre avec des 1
+void genTabConst(long tabARemplir[], size_t tailleTab);
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires négatives
+void genTabNeg(long tabARemplir[], size_t tailleTab, int maxVal);
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires tiré dans l'ordre décroissant
+void genTabDecroi(long tabARemplir[], size_t tailleTab, int maxVal);
+int longComparatorDecroi( const void * first, const void * second );
+
+//Remplis le tableau passé en paramètre de valeurs aléatoires tiré dans l'ordre croissant
+void genTabCroi(long tabARemplir[], size_t tailleTab, int maxVal);
+int longComparatorCroi( const void * first, const void * second );
+
+//compte le nombre de comparaisons
+void compter(long* i);
+
+//affiche les infos de compteur
+void affiche_infos(struct compteur cpt);
diff --git a/TP3/main.c b/TP3/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..902a4cb907fa2b8f8b861aaa6ee38a3f9f5622bd
--- /dev/null
+++ b/TP3/main.c
@@ -0,0 +1,67 @@
+#include "tri_fusion.h"
+#include "tri_rapide.h"
+#include "tri_insertion.h"
+#include "tri_bulle.h"
+#include "tri_fusion_opti.h"
+#include "function.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char const *argv[]) {
+
+  if(argc < 4){
+    printf("Usage: ./main taille maxVal typeTri typeTableau\n");
+    exit(1);
+  }
+  int tailleTab = atoi(argv[1]);
+  int maxVal = atoi(argv[2]);
+  int typeTri = atoi(argv[3]);
+  int typeTableau = atoi(argv[4]);
+
+  printf("Taille du tableau : %d\n", tailleTab);
+  long tableauBis[tailleTab];
+  memset(tableauBis, 0, tailleTab*sizeof(long));
+  printf("--- Tableau initial ---\n");
+
+  //choisir le type de tableau à générer
+  switch (typeTableau) {
+    case 1:
+      genTabAlea(tableauBis,tailleTab, maxVal);
+      break;
+    case 2:
+      genTabCroi(tableauBis,tailleTab, maxVal);
+      break;
+    case 3:
+      genTabDecroi(tableauBis,tailleTab, maxVal);
+      break;
+    case 4:
+      genTabConst(tableauBis,tailleTab);
+      break;
+    case 5:
+      genTabNeg(tableauBis,tailleTab, maxVal);
+      break;
+  }
+  afficheTab(tableauBis,tailleTab);
+
+  //choisir le type de tri à utiliser
+  switch (typeTri) {
+    case 1:
+      tri_insertion(tableauBis,tailleTab);
+      break;
+    case 2:
+      triFusion(tableauBis,tailleTab);
+      break;
+    case 3:
+      triRapide(tableauBis,tailleTab);
+      break;
+    case 4:
+      triBulle(tableauBis,tailleTab);
+      break;
+    case 5:
+      triFusionOpti(tableauBis,tailleTab);
+      break;
+  }
+  afficheTab(tableauBis,tailleTab);
+
+  return 0;
+}
diff --git a/TP3/makefile b/TP3/makefile
new file mode 100644
index 0000000000000000000000000000000000000000..cb1bea7d451118ce3d7fb24bf8c4c46c39e51260
--- /dev/null
+++ b/TP3/makefile
@@ -0,0 +1,24 @@
+all: main
+main: main.c tri_fusion.o tri_rapide.o tri_insertion.o tri_bulle.o tri_fusion_opti.o function.o
+	gcc -Wall -o main tri_fusion.o tri_rapide.o tri_insertion.o tri_bulle.o tri_fusion_opti.o function.o main.c
+
+tri_fusion.o: tri_fusion.h tri_fusion.c
+	gcc -Wall -c tri_fusion.c
+
+tri_rapide.o: tri_rapide.h tri_rapide.c
+	gcc -Wall -c tri_rapide.c
+
+tri_insertion.o: tri_insertion.h tri_insertion.c
+	gcc -c tri_insertion.c -Wall
+
+tri_bulle.o: tri_bulle.h tri_bulle.c
+	gcc -c tri_bulle.c -Wall
+
+tri_fusion_opti.o: tri_fusion_opti.h tri_fusion_opti.c
+	gcc -Wall -c tri_fusion_opti.c
+
+function.o: function.h function.c
+	gcc -c function.c -Wall
+
+clean:
+	rm *.o main
diff --git a/TP3/perf.R b/TP3/perf.R
new file mode 100755
index 0000000000000000000000000000000000000000..ccb99507b2021d2134b6a2613428b4962d790fb7
--- /dev/null
+++ b/TP3/perf.R
@@ -0,0 +1,17 @@
+#!/usr/bin/env Rscript
+
+library(ggplot2)
+
+perf <- read.table("perf.dat", header = TRUE)
+perf$typeTri <- factor(perf$typeTri, levels=c("tri_insertion", "tri_fusion", "tri_rapide", "tri_bulle"))
+
+ggplot(perf, aes(x=taille, y=temps, group=typeTri, colour=typeTri), cex.axis=0.4) + geom_point() + geom_smooth() + ggtitle("Temps d'exécution en fonction de la taille du tableau") + facet_grid(typeTableau ~ typeTri) + theme(text = element_text(size=5.5))
+
+ggsave("./Graphes/graphesTps.png")
+
+ggplot(perf, aes(x=taille, y=memoire, group=typeTri, colour=typeTri), cex.axis=0.4) + geom_point() + geom_smooth() + ggtitle("Utilisation mémoire en fonction de la taille du tableau") + facet_grid(typeTableau ~ typeTri) + theme(text = element_text(size=5.5))
+
+ggsave("./Graphes/graphesMem.png")
+
+file.exists("Rplots.pdf")
+file.remove("Rplots.pdf")
diff --git a/TP3/perf.dat b/TP3/perf.dat
new file mode 100644
index 0000000000000000000000000000000000000000..17af4ed6c6e77097812ce6e89a12c8e842413bd0
--- /dev/null
+++ b/TP3/perf.dat
@@ -0,0 +1,401 @@
+nTest	taille	max	typeTri	typeTableau	temps	memoire
+1	29740	10000	tri_insertion	tab_alea	1.10	1732
+1	29740	10000	tri_insertion	tab_trie	0.01	1888
+1	29740	10000	tri_insertion	tab_triInverse	2.15	1848
+1	29740	10000	tri_insertion	tab_constant	0.01	1696
+1	29740	10000	tri_insertion	tab_aleaNegatifs	1.08	1732
+1	29740	10000	tri_fusion	tab_alea	0.02	6240
+1	29740	10000	tri_fusion	tab_trie	0.01	6264
+1	29740	10000	tri_fusion	tab_triInverse	0.02	6288
+1	29740	10000	tri_fusion	tab_constant	0.01	6256
+1	29740	10000	tri_fusion	tab_aleaNegatifs	0.02	6288
+1	29740	10000	tri_rapide	tab_alea	0.01	1724
+1	29740	10000	tri_rapide	tab_trie	4.76	3584
+1	29740	10000	tri_rapide	tab_triInverse	1.58	2584
+1	29740	10000	tri_rapide	tab_constant	4.87	3544
+1	29740	10000	tri_rapide	tab_aleaNegatifs	0.02	1720
+1	29740	10000	tri_bulle	tab_alea	4.34	1668
+1	29740	10000	tri_bulle	tab_trie	0.01	1876
+1	29740	10000	tri_bulle	tab_triInverse	3.62	1828
+1	29740	10000	tri_bulle	tab_constant	0.00	1728
+1	29740	10000	tri_bulle	tab_aleaNegatifs	4.63	1756
+2	20357	10000	tri_insertion	tab_alea	0.53	1672
+2	20357	10000	tri_insertion	tab_trie	0.00	1632
+2	20357	10000	tri_insertion	tab_triInverse	1.09	1672
+2	20357	10000	tri_insertion	tab_constant	0.00	1612
+2	20357	10000	tri_insertion	tab_aleaNegatifs	0.53	1672
+2	20357	10000	tri_fusion	tab_alea	0.00	4640
+2	20357	10000	tri_fusion	tab_trie	0.02	4624
+2	20357	10000	tri_fusion	tab_triInverse	0.01	4700
+2	20357	10000	tri_fusion	tab_constant	0.00	4628
+2	20357	10000	tri_fusion	tab_aleaNegatifs	0.01	4764
+2	20357	10000	tri_rapide	tab_alea	0.01	1744
+2	20357	10000	tri_rapide	tab_trie	2.32	2880
+2	20357	10000	tri_rapide	tab_triInverse	0.90	2432
+2	20357	10000	tri_rapide	tab_constant	2.30	2908
+2	20357	10000	tri_rapide	tab_aleaNegatifs	0.01	1608
+2	20357	10000	tri_bulle	tab_alea	2.05	1636
+2	20357	10000	tri_bulle	tab_trie	0.01	1632
+2	20357	10000	tri_bulle	tab_triInverse	1.70	1640
+2	20357	10000	tri_bulle	tab_constant	0.00	1612
+2	20357	10000	tri_bulle	tab_aleaNegatifs	2.02	1648
+3	21549	10000	tri_insertion	tab_alea	0.63	1644
+3	21549	10000	tri_insertion	tab_trie	0.01	1660
+3	21549	10000	tri_insertion	tab_triInverse	1.22	1684
+3	21549	10000	tri_insertion	tab_constant	0.00	1628
+3	21549	10000	tri_insertion	tab_aleaNegatifs	0.62	1660
+3	21549	10000	tri_fusion	tab_alea	0.01	4816
+3	21549	10000	tri_fusion	tab_trie	0.02	4816
+3	21549	10000	tri_fusion	tab_triInverse	0.01	4812
+3	21549	10000	tri_fusion	tab_constant	0.01	4744
+3	21549	10000	tri_fusion	tab_aleaNegatifs	0.01	4772
+3	21549	10000	tri_rapide	tab_alea	0.00	1652
+3	21549	10000	tri_rapide	tab_trie	2.67	2960
+3	21549	10000	tri_rapide	tab_triInverse	0.95	2352
+3	21549	10000	tri_rapide	tab_constant	2.54	2964
+3	21549	10000	tri_rapide	tab_aleaNegatifs	0.01	1668
+3	21549	10000	tri_bulle	tab_alea	2.23	1672
+3	21549	10000	tri_bulle	tab_trie	0.01	1688
+3	21549	10000	tri_bulle	tab_triInverse	1.84	1668
+3	21549	10000	tri_bulle	tab_constant	0.00	1668
+3	21549	10000	tri_bulle	tab_aleaNegatifs	2.12	1576
+4	11522	10000	tri_insertion	tab_alea	0.15	1596
+4	11522	10000	tri_insertion	tab_trie	0.00	1556
+4	11522	10000	tri_insertion	tab_triInverse	0.32	1692
+4	11522	10000	tri_insertion	tab_constant	0.00	1568
+4	11522	10000	tri_insertion	tab_aleaNegatifs	0.16	1600
+4	11522	10000	tri_fusion	tab_alea	0.01	3212
+4	11522	10000	tri_fusion	tab_trie	0.01	3200
+4	11522	10000	tri_fusion	tab_triInverse	0.01	3216
+4	11522	10000	tri_fusion	tab_constant	0.00	3152
+4	11522	10000	tri_fusion	tab_aleaNegatifs	0.00	3228
+4	11522	10000	tri_rapide	tab_alea	0.00	1572
+4	11522	10000	tri_rapide	tab_trie	0.70	2396
+4	11522	10000	tri_rapide	tab_triInverse	0.30	2120
+4	11522	10000	tri_rapide	tab_constant	0.70	2300
+4	11522	10000	tri_rapide	tab_aleaNegatifs	0.01	1540
+4	11522	10000	tri_bulle	tab_alea	0.59	1540
+4	11522	10000	tri_bulle	tab_trie	0.00	1676
+4	11522	10000	tri_bulle	tab_triInverse	0.54	1764
+4	11522	10000	tri_bulle	tab_constant	0.00	1580
+4	11522	10000	tri_bulle	tab_aleaNegatifs	0.59	1524
+5	46610	10000	tri_insertion	tab_alea	2.71	1828
+5	46610	10000	tri_insertion	tab_trie	0.01	2152
+5	46610	10000	tri_insertion	tab_triInverse	5.42	2108
+5	46610	10000	tri_insertion	tab_constant	0.00	1852
+5	46610	10000	tri_insertion	tab_aleaNegatifs	2.71	1816
+5	46610	10000	tri_fusion	tab_alea	0.02	9072
+5	46610	10000	tri_fusion	tab_trie	0.03	9156
+5	46610	10000	tri_fusion	tab_triInverse	0.03	9204
+5	46610	10000	tri_fusion	tab_constant	0.02	9160
+5	46610	10000	tri_fusion	tab_aleaNegatifs	0.02	9104
+5	46610	10000	tri_rapide	tab_alea	0.01	1872
+5	46610	10000	tri_rapide	tab_trie	11.45	4736
+5	46610	10000	tri_rapide	tab_triInverse	3.73	3024
+5	46610	10000	tri_rapide	tab_constant	11.38	4656
+5	46610	10000	tri_rapide	tab_aleaNegatifs	0.02	1880
+5	46610	10000	tri_bulle	tab_alea	10.46	1840
+5	46610	10000	tri_bulle	tab_trie	0.02	2128
+5	46610	10000	tri_bulle	tab_triInverse	8.74	2120
+5	46610	10000	tri_bulle	tab_constant	0.01	1816
+5	46610	10000	tri_bulle	tab_aleaNegatifs	10.83	1816
+6	16876	10000	tri_insertion	tab_alea	0.36	1632
+6	16876	10000	tri_insertion	tab_trie	0.00	1564
+6	16876	10000	tri_insertion	tab_triInverse	0.73	1632
+6	16876	10000	tri_insertion	tab_constant	0.00	1624
+6	16876	10000	tri_insertion	tab_aleaNegatifs	0.36	1600
+6	16876	10000	tri_fusion	tab_alea	0.01	4060
+6	16876	10000	tri_fusion	tab_trie	0.00	4132
+6	16876	10000	tri_fusion	tab_triInverse	0.00	4096
+6	16876	10000	tri_fusion	tab_constant	0.00	4148
+6	16876	10000	tri_fusion	tab_aleaNegatifs	0.00	4148
+6	16876	10000	tri_rapide	tab_alea	0.01	1596
+6	16876	10000	tri_rapide	tab_trie	1.57	2656
+6	16876	10000	tri_rapide	tab_triInverse	0.59	2116
+6	16876	10000	tri_rapide	tab_constant	1.51	2648
+6	16876	10000	tri_rapide	tab_aleaNegatifs	0.01	1584
+6	16876	10000	tri_bulle	tab_alea	1.36	1580
+6	16876	10000	tri_bulle	tab_trie	0.00	1636
+6	16876	10000	tri_bulle	tab_triInverse	1.12	1580
+6	16876	10000	tri_bulle	tab_constant	0.00	1624
+6	16876	10000	tri_bulle	tab_aleaNegatifs	1.34	1648
+7	37984	10000	tri_insertion	tab_alea	1.77	1764
+7	37984	10000	tri_insertion	tab_trie	0.02	1904
+7	37984	10000	tri_insertion	tab_triInverse	3.63	1876
+7	37984	10000	tri_insertion	tab_constant	0.00	1724
+7	37984	10000	tri_insertion	tab_aleaNegatifs	1.80	1748
+7	37984	10000	tri_fusion	tab_alea	0.02	7704
+7	37984	10000	tri_fusion	tab_trie	0.02	7700
+7	37984	10000	tri_fusion	tab_triInverse	0.02	7680
+7	37984	10000	tri_fusion	tab_constant	0.01	7684
+7	37984	10000	tri_fusion	tab_aleaNegatifs	0.02	7632
+7	37984	10000	tri_rapide	tab_alea	0.02	1748
+7	37984	10000	tri_rapide	tab_trie	8.07	4184
+7	37984	10000	tri_rapide	tab_triInverse	2.53	2780
+7	37984	10000	tri_rapide	tab_constant	7.66	4136
+7	37984	10000	tri_rapide	tab_aleaNegatifs	0.01	1772
+7	37984	10000	tri_bulle	tab_alea	6.99	1804
+7	37984	10000	tri_bulle	tab_trie	0.01	1900
+7	37984	10000	tri_bulle	tab_triInverse	5.91	1872
+7	37984	10000	tri_bulle	tab_constant	0.01	1804
+7	37984	10000	tri_bulle	tab_aleaNegatifs	6.97	1676
+8	19279	10000	tri_insertion	tab_alea	0.46	1604
+8	19279	10000	tri_insertion	tab_trie	0.01	1620
+8	19279	10000	tri_insertion	tab_triInverse	0.95	1600
+8	19279	10000	tri_insertion	tab_constant	0.00	1600
+8	19279	10000	tri_insertion	tab_aleaNegatifs	0.48	1556
+8	19279	10000	tri_fusion	tab_alea	0.01	4444
+8	19279	10000	tri_fusion	tab_trie	0.01	4480
+8	19279	10000	tri_fusion	tab_triInverse	0.01	4472
+8	19279	10000	tri_fusion	tab_constant	0.01	4504
+8	19279	10000	tri_fusion	tab_aleaNegatifs	0.00	4444
+8	19279	10000	tri_rapide	tab_alea	0.00	1640
+8	19279	10000	tri_rapide	tab_trie	2.01	2836
+8	19279	10000	tri_rapide	tab_triInverse	0.79	2308
+8	19279	10000	tri_rapide	tab_constant	2.04	2760
+8	19279	10000	tri_rapide	tab_aleaNegatifs	0.01	1600
+8	19279	10000	tri_bulle	tab_alea	1.78	1528
+8	19279	10000	tri_bulle	tab_trie	0.00	1632
+8	19279	10000	tri_bulle	tab_triInverse	1.54	1624
+8	19279	10000	tri_bulle	tab_constant	0.00	1632
+8	19279	10000	tri_bulle	tab_aleaNegatifs	1.80	1628
+9	31947	10000	tri_insertion	tab_alea	1.27	1712
+9	31947	10000	tri_insertion	tab_trie	0.01	1856
+9	31947	10000	tri_insertion	tab_triInverse	2.71	1900
+9	31947	10000	tri_insertion	tab_constant	0.01	1716
+9	31947	10000	tri_insertion	tab_aleaNegatifs	1.24	1628
+9	31947	10000	tri_fusion	tab_alea	0.02	6700
+9	31947	10000	tri_fusion	tab_trie	0.01	6676
+9	31947	10000	tri_fusion	tab_triInverse	0.02	6668
+9	31947	10000	tri_fusion	tab_constant	0.01	6708
+9	31947	10000	tri_fusion	tab_aleaNegatifs	0.02	6792
+9	31947	10000	tri_rapide	tab_alea	0.01	1748
+9	31947	10000	tri_rapide	tab_trie	5.58	3752
+9	31947	10000	tri_rapide	tab_triInverse	1.93	2652
+9	31947	10000	tri_rapide	tab_constant	5.67	3680
+9	31947	10000	tri_rapide	tab_aleaNegatifs	0.01	1836
+9	31947	10000	tri_bulle	tab_alea	4.83	1836
+9	31947	10000	tri_bulle	tab_trie	0.01	1876
+9	31947	10000	tri_bulle	tab_triInverse	4.01	1864
+9	31947	10000	tri_bulle	tab_constant	0.00	1720
+9	31947	10000	tri_bulle	tab_aleaNegatifs	4.81	1756
+10	40894	10000	tri_insertion	tab_alea	1.98	1832
+10	40894	10000	tri_insertion	tab_trie	0.02	1880
+10	40894	10000	tri_insertion	tab_triInverse	4.01	1828
+10	40894	10000	tri_insertion	tab_constant	0.01	1752
+10	40894	10000	tri_insertion	tab_aleaNegatifs	2.04	1904
+10	40894	10000	tri_fusion	tab_alea	0.02	8156
+10	40894	10000	tri_fusion	tab_trie	0.02	8176
+10	40894	10000	tri_fusion	tab_triInverse	0.02	8168
+10	40894	10000	tri_fusion	tab_constant	0.02	8212
+10	40894	10000	tri_fusion	tab_aleaNegatifs	0.02	8112
+10	40894	10000	tri_rapide	tab_alea	0.01	1784
+10	40894	10000	tri_rapide	tab_trie	9.13	4396
+10	40894	10000	tri_rapide	tab_triInverse	2.92	2868
+10	40894	10000	tri_rapide	tab_constant	9.08	4280
+10	40894	10000	tri_rapide	tab_aleaNegatifs	0.02	1908
+10	40894	10000	tri_bulle	tab_alea	8.58	1696
+10	40894	10000	tri_bulle	tab_trie	0.01	1852
+10	40894	10000	tri_bulle	tab_triInverse	6.85	1888
+10	40894	10000	tri_bulle	tab_constant	0.01	1768
+10	40894	10000	tri_bulle	tab_aleaNegatifs	8.17	1840
+11	34846	10000	tri_insertion	tab_alea	1.46	1708
+11	34846	10000	tri_insertion	tab_trie	0.01	1848
+11	34846	10000	tri_insertion	tab_triInverse	2.94	1876
+11	34846	10000	tri_insertion	tab_constant	0.00	1788
+11	34846	10000	tri_insertion	tab_aleaNegatifs	1.50	1720
+11	34846	10000	tri_fusion	tab_alea	0.02	7140
+11	34846	10000	tri_fusion	tab_trie	0.02	7180
+11	34846	10000	tri_fusion	tab_triInverse	0.01	7148
+11	34846	10000	tri_fusion	tab_constant	0.01	7152
+11	34846	10000	tri_fusion	tab_aleaNegatifs	0.02	7140
+11	34846	10000	tri_rapide	tab_alea	0.01	1796
+11	34846	10000	tri_rapide	tab_trie	6.37	3896
+11	34846	10000	tri_rapide	tab_triInverse	2.15	2748
+11	34846	10000	tri_rapide	tab_constant	6.48	3964
+11	34846	10000	tri_rapide	tab_aleaNegatifs	0.02	1652
+11	34846	10000	tri_bulle	tab_alea	6.00	1724
+11	34846	10000	tri_bulle	tab_trie	0.01	1856
+11	34846	10000	tri_bulle	tab_triInverse	4.98	1880
+11	34846	10000	tri_bulle	tab_constant	0.00	1676
+11	34846	10000	tri_bulle	tab_aleaNegatifs	6.16	1788
+12	9059	10000	tri_insertion	tab_alea	0.11	1520
+12	9059	10000	tri_insertion	tab_trie	0.00	1652
+12	9059	10000	tri_insertion	tab_triInverse	0.21	1612
+12	9059	10000	tri_insertion	tab_constant	0.00	1448
+12	9059	10000	tri_insertion	tab_aleaNegatifs	0.11	1520
+12	9059	10000	tri_fusion	tab_alea	0.01	2780
+12	9059	10000	tri_fusion	tab_trie	0.00	2848
+12	9059	10000	tri_fusion	tab_triInverse	0.00	2844
+12	9059	10000	tri_fusion	tab_constant	0.00	2768
+12	9059	10000	tri_fusion	tab_aleaNegatifs	0.01	2820
+12	9059	10000	tri_rapide	tab_alea	0.00	1544
+12	9059	10000	tri_rapide	tab_trie	0.47	2204
+12	9059	10000	tri_rapide	tab_triInverse	0.21	2012
+12	9059	10000	tri_rapide	tab_constant	0.44	2068
+12	9059	10000	tri_rapide	tab_aleaNegatifs	0.00	1520
+12	9059	10000	tri_bulle	tab_alea	0.37	1524
+12	9059	10000	tri_bulle	tab_trie	0.00	1652
+12	9059	10000	tri_bulle	tab_triInverse	0.34	1612
+12	9059	10000	tri_bulle	tab_constant	0.00	1536
+12	9059	10000	tri_bulle	tab_aleaNegatifs	0.39	1448
+13	9312	10000	tri_insertion	tab_alea	0.12	1548
+13	9312	10000	tri_insertion	tab_trie	0.00	1596
+13	9312	10000	tri_insertion	tab_triInverse	0.21	1612
+13	9312	10000	tri_insertion	tab_constant	0.00	1508
+13	9312	10000	tri_insertion	tab_aleaNegatifs	0.10	1480
+13	9312	10000	tri_fusion	tab_alea	0.00	2824
+13	9312	10000	tri_fusion	tab_trie	0.00	2836
+13	9312	10000	tri_fusion	tab_triInverse	0.00	2856
+13	9312	10000	tri_fusion	tab_constant	0.00	2824
+13	9312	10000	tri_fusion	tab_aleaNegatifs	0.00	2824
+13	9312	10000	tri_rapide	tab_alea	0.00	1564
+13	9312	10000	tri_rapide	tab_trie	0.47	2200
+13	9312	10000	tri_rapide	tab_triInverse	0.21	2016
+13	9312	10000	tri_rapide	tab_constant	0.47	2176
+13	9312	10000	tri_rapide	tab_aleaNegatifs	0.00	1508
+13	9312	10000	tri_bulle	tab_alea	0.38	1524
+13	9312	10000	tri_bulle	tab_trie	0.00	1640
+13	9312	10000	tri_bulle	tab_triInverse	0.35	1668
+13	9312	10000	tri_bulle	tab_constant	0.00	1580
+13	9312	10000	tri_bulle	tab_aleaNegatifs	0.39	1508
+14	1681	10000	tri_insertion	tab_alea	0.00	1420
+14	1681	10000	tri_insertion	tab_trie	0.00	1488
+14	1681	10000	tri_insertion	tab_triInverse	0.01	1488
+14	1681	10000	tri_insertion	tab_constant	0.00	1600
+14	1681	10000	tri_insertion	tab_aleaNegatifs	0.01	1392
+14	1681	10000	tri_fusion	tab_alea	0.00	1588
+14	1681	10000	tri_fusion	tab_trie	0.00	1712
+14	1681	10000	tri_fusion	tab_triInverse	0.00	1676
+14	1681	10000	tri_fusion	tab_constant	0.00	1664
+14	1681	10000	tri_fusion	tab_aleaNegatifs	0.00	1712
+14	1681	10000	tri_rapide	tab_alea	0.00	1480
+14	1681	10000	tri_rapide	tab_trie	0.01	1712
+14	1681	10000	tri_rapide	tab_triInverse	0.00	1608
+14	1681	10000	tri_rapide	tab_constant	0.01	1632
+14	1681	10000	tri_rapide	tab_aleaNegatifs	0.00	1488
+14	1681	10000	tri_bulle	tab_alea	0.01	1464
+14	1681	10000	tri_bulle	tab_trie	0.00	1516
+14	1681	10000	tri_bulle	tab_triInverse	0.01	1612
+14	1681	10000	tri_bulle	tab_constant	0.00	1444
+14	1681	10000	tri_bulle	tab_aleaNegatifs	0.01	1464
+15	19259	10000	tri_insertion	tab_alea	0.45	1648
+15	19259	10000	tri_insertion	tab_trie	0.00	1624
+15	19259	10000	tri_insertion	tab_triInverse	0.91	1628
+15	19259	10000	tri_insertion	tab_constant	0.00	1672
+15	19259	10000	tri_insertion	tab_aleaNegatifs	0.48	1600
+15	19259	10000	tri_fusion	tab_alea	0.01	4460
+15	19259	10000	tri_fusion	tab_trie	0.00	4472
+15	19259	10000	tri_fusion	tab_triInverse	0.00	4500
+15	19259	10000	tri_fusion	tab_constant	0.01	4468
+15	19259	10000	tri_fusion	tab_aleaNegatifs	0.01	4448
+15	19259	10000	tri_rapide	tab_alea	0.00	1672
+15	19259	10000	tri_rapide	tab_trie	2.06	2828
+15	19259	10000	tri_rapide	tab_triInverse	0.77	2272
+15	19259	10000	tri_rapide	tab_constant	2.10	2940
+15	19259	10000	tri_rapide	tab_aleaNegatifs	0.01	1664
+15	19259	10000	tri_bulle	tab_alea	1.75	1600
+15	19259	10000	tri_bulle	tab_trie	0.00	1664
+15	19259	10000	tri_bulle	tab_triInverse	1.47	1604
+15	19259	10000	tri_bulle	tab_constant	0.00	1640
+15	19259	10000	tri_bulle	tab_aleaNegatifs	1.75	1584
+16	21375	10000	tri_insertion	tab_alea	0.55	1676
+16	21375	10000	tri_insertion	tab_trie	0.01	1632
+16	21375	10000	tri_insertion	tab_triInverse	1.13	1664
+16	21375	10000	tri_insertion	tab_constant	0.00	1648
+16	21375	10000	tri_insertion	tab_aleaNegatifs	0.55	1752
+16	21375	10000	tri_fusion	tab_alea	0.01	4800
+16	21375	10000	tri_fusion	tab_trie	0.01	4712
+16	21375	10000	tri_fusion	tab_triInverse	0.00	4816
+16	21375	10000	tri_fusion	tab_constant	0.01	4824
+16	21375	10000	tri_fusion	tab_aleaNegatifs	0.01	4812
+16	21375	10000	tri_rapide	tab_alea	0.01	1572
+16	21375	10000	tri_rapide	tab_trie	2.47	2984
+16	21375	10000	tri_rapide	tab_triInverse	0.92	2332
+16	21375	10000	tri_rapide	tab_constant	2.51	2976
+16	21375	10000	tri_rapide	tab_aleaNegatifs	0.01	1672
+16	21375	10000	tri_bulle	tab_alea	2.19	1604
+16	21375	10000	tri_bulle	tab_trie	0.01	1616
+16	21375	10000	tri_bulle	tab_triInverse	1.90	1616
+16	21375	10000	tri_bulle	tab_constant	0.00	1616
+16	21375	10000	tri_bulle	tab_aleaNegatifs	2.14	1544
+17	48517	10000	tri_insertion	tab_alea	2.84	1844
+17	48517	10000	tri_insertion	tab_trie	0.02	2116
+17	48517	10000	tri_insertion	tab_triInverse	5.80	2112
+17	48517	10000	tri_insertion	tab_constant	0.01	1756
+17	48517	10000	tri_insertion	tab_aleaNegatifs	2.89	1892
+17	48517	10000	tri_fusion	tab_alea	0.02	9516
+17	48517	10000	tri_fusion	tab_trie	0.03	9508
+17	48517	10000	tri_fusion	tab_triInverse	0.02	9516
+17	48517	10000	tri_fusion	tab_constant	0.02	9556
+17	48517	10000	tri_fusion	tab_aleaNegatifs	0.02	9568
+17	48517	10000	tri_rapide	tab_alea	0.01	1852
+17	48517	10000	tri_rapide	tab_trie	12.93	4864
+17	48517	10000	tri_rapide	tab_triInverse	3.87	3024
+17	48517	10000	tri_rapide	tab_constant	12.94	4996
+17	48517	10000	tri_rapide	tab_aleaNegatifs	0.02	1844
+17	48517	10000	tri_bulle	tab_alea	11.86	1844
+17	48517	10000	tri_bulle	tab_trie	0.01	2164
+17	48517	10000	tri_bulle	tab_triInverse	9.48	2116
+17	48517	10000	tri_bulle	tab_constant	0.01	1760
+17	48517	10000	tri_bulle	tab_aleaNegatifs	11.50	1892
+18	876	10000	tri_insertion	tab_alea	0.00	1460
+18	876	10000	tri_insertion	tab_trie	0.00	1504
+18	876	10000	tri_insertion	tab_triInverse	0.00	1476
+18	876	10000	tri_insertion	tab_constant	0.00	1480
+18	876	10000	tri_insertion	tab_aleaNegatifs	0.00	1592
+18	876	10000	tri_fusion	tab_alea	0.00	1584
+18	876	10000	tri_fusion	tab_trie	0.00	1624
+18	876	10000	tri_fusion	tab_triInverse	0.00	1596
+18	876	10000	tri_fusion	tab_constant	0.00	1628
+18	876	10000	tri_fusion	tab_aleaNegatifs	0.00	1536
+18	876	10000	tri_rapide	tab_alea	0.00	1504
+18	876	10000	tri_rapide	tab_trie	0.00	1548
+18	876	10000	tri_rapide	tab_triInverse	0.00	1560
+18	876	10000	tri_rapide	tab_constant	0.00	1512
+18	876	10000	tri_rapide	tab_aleaNegatifs	0.00	1592
+18	876	10000	tri_bulle	tab_alea	0.00	1592
+18	876	10000	tri_bulle	tab_trie	0.00	1480
+18	876	10000	tri_bulle	tab_triInverse	0.00	1388
+18	876	10000	tri_bulle	tab_constant	0.00	1412
+18	876	10000	tri_bulle	tab_aleaNegatifs	0.00	1528
+19	32705	10000	tri_insertion	tab_alea	1.41	1768
+19	32705	10000	tri_insertion	tab_trie	0.01	1872
+19	32705	10000	tri_insertion	tab_triInverse	2.62	1900
+19	32705	10000	tri_insertion	tab_constant	0.01	1684
+19	32705	10000	tri_insertion	tab_aleaNegatifs	1.45	1724
+19	32705	10000	tri_fusion	tab_alea	0.02	6868
+19	32705	10000	tri_fusion	tab_trie	0.02	6808
+19	32705	10000	tri_fusion	tab_triInverse	0.02	6864
+19	32705	10000	tri_fusion	tab_constant	0.01	6828
+19	32705	10000	tri_fusion	tab_aleaNegatifs	0.02	6884
+19	32705	10000	tri_rapide	tab_alea	0.01	1744
+19	32705	10000	tri_rapide	tab_trie	5.96	3748
+19	32705	10000	tri_rapide	tab_triInverse	2.04	2644
+19	32705	10000	tri_rapide	tab_constant	6.00	3788
+19	32705	10000	tri_rapide	tab_aleaNegatifs	0.02	1720
+19	32705	10000	tri_bulle	tab_alea	5.33	1692
+19	32705	10000	tri_bulle	tab_trie	0.01	1860
+19	32705	10000	tri_bulle	tab_triInverse	4.28	1872
+19	32705	10000	tri_bulle	tab_constant	0.00	1692
+19	32705	10000	tri_bulle	tab_aleaNegatifs	5.15	1688
+20	348	10000	tri_insertion	tab_alea	0.00	1524
+20	348	10000	tri_insertion	tab_trie	0.00	1512
+20	348	10000	tri_insertion	tab_triInverse	0.00	1516
+20	348	10000	tri_insertion	tab_constant	0.00	1500
+20	348	10000	tri_insertion	tab_aleaNegatifs	0.00	1476
+20	348	10000	tri_fusion	tab_alea	0.00	1536
+20	348	10000	tri_fusion	tab_trie	0.00	1516
+20	348	10000	tri_fusion	tab_triInverse	0.00	1492
+20	348	10000	tri_fusion	tab_constant	0.00	1504
+20	348	10000	tri_fusion	tab_aleaNegatifs	0.00	1540
+20	348	10000	tri_rapide	tab_alea	0.00	1384
+20	348	10000	tri_rapide	tab_trie	0.00	1500
+20	348	10000	tri_rapide	tab_triInverse	0.00	1536
+20	348	10000	tri_rapide	tab_constant	0.00	1432
+20	348	10000	tri_rapide	tab_aleaNegatifs	0.00	1528
+20	348	10000	tri_bulle	tab_alea	0.00	1452
+20	348	10000	tri_bulle	tab_trie	0.00	1380
+20	348	10000	tri_bulle	tab_triInverse	0.00	1452
+20	348	10000	tri_bulle	tab_constant	0.00	1468
+20	348	10000	tri_bulle	tab_aleaNegatifs	0.00	1452
diff --git a/TP3/perf.sh b/TP3/perf.sh
new file mode 100755
index 0000000000000000000000000000000000000000..79e4b658c2308882cd11f49a761fc5c320f1e357
--- /dev/null
+++ b/TP3/perf.sh
@@ -0,0 +1,37 @@
+#!bin/bash
+
+echo "nTest\ttaille\tmax\ttypeTri\ttypeTableau\ttemps\tmemoire"
+
+max=10000
+TYPETRITAB="${TYPETRITAB} tri_insertion"
+TYPETRITAB="${TYPETRITAB} tri_fusion"
+TYPETRITAB="${TYPETRITAB} tri_rapide"
+TYPETRITAB="${TYPETRITAB} tri_bulle"
+compteurTypeTri=0
+
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_alea"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_trie"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_triInverse"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_constant"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_aleaNegatifs"
+compteurTypeTableau=0
+
+for nTest in `seq 1 20`
+do
+  compteurTypeTri=0
+
+  taille=$(( `od -An -N4 -tu < /dev/urandom` % 50000))
+  for TYPETRI in ${TYPETRITAB}
+  do
+    compteurTypeTri=$((compteurTypeTri + 1)) #On incrémente valeur pour lancer main
+    compteurTypeTableau=0  #On réinitialise la valeur du tab, pour jamais être au dessus de 3
+
+    for TYPETABLEAU in ${TYPETABLEAUTAB}
+    do
+        compteurTypeTableau=$((compteurTypeTableau + 1))
+
+        res=`(/usr/bin/time -f "%U\t%M" ./main $taille $max $compteurTypeTri $compteurTypeTableau > /dev/null) 2>&1`
+        echo "$nTest\t$taille\t$max\t${TYPETRI}\t${TYPETABLEAU}\t$res"
+    done
+  done
+done
diff --git a/TP3/perfHyp.R b/TP3/perfHyp.R
new file mode 100644
index 0000000000000000000000000000000000000000..b124251e39bec70aa8009b6374c54823eb724ac9
--- /dev/null
+++ b/TP3/perfHyp.R
@@ -0,0 +1,17 @@
+#!/usr/bin/env Rscript
+
+library(ggplot2)
+
+perf <- read.table("perfHyp.dat", header = TRUE)
+perf$typeTri <- factor(perf$typeTri, levels=c("tri_fusion", "tri_fusion_opti"))
+
+ggplot(perf, aes(x=taille, y=temps, group=typeTri, colour=typeTri), cex.axis=0.4) + geom_point() + geom_smooth() + ggtitle("Temps d'exécution en fonction de la taille du tableau") + facet_grid(typeTableau ~ typeTri) + theme(text = element_text(size=7))
+
+ggsave("./Graphes/graphesTpsHyp.png")
+
+ggplot(perf, aes(x=taille, y=memoire, group=typeTri, colour=typeTri), cex.axis=0.4) + geom_point() + geom_smooth() + ggtitle("Utilisation mémoire en fonction de la taille du tableau") + facet_grid(typeTableau ~ typeTri) + theme(text = element_text(size=7))
+
+ggsave("./Graphes/graphesMemHyp.png")
+
+file.exists("Rplots.pdf")
+file.remove("Rplots.pdf")
diff --git a/TP3/perfHyp.dat b/TP3/perfHyp.dat
new file mode 100644
index 0000000000000000000000000000000000000000..15c17025a086fc51a3f34c0e61cffbb1bdff65b3
--- /dev/null
+++ b/TP3/perfHyp.dat
@@ -0,0 +1,501 @@
+nTest	taille	max	typeTri	typeTableau	temps	memoire
+1	583386	10000	tri_fusion	tab_alea	0.67	114764
+1	583386	10000	tri_fusion	tab_trie	0.87	114724
+1	583386	10000	tri_fusion	tab_triInverse	0.87	114696
+1	583386	10000	tri_fusion	tab_constant	0.55	114848
+1	583386	10000	tri_fusion	tab_aleaNegatifs	0.63	114732
+1	583386	10000	tri_fusion_opti	tab_alea	0.62	10640
+1	583386	10000	tri_fusion_opti	tab_trie	0.78	10528
+1	583386	10000	tri_fusion_opti	tab_triInverse	0.77	10532
+1	583386	10000	tri_fusion_opti	tab_constant	0.53	10528
+1	583386	10000	tri_fusion_opti	tab_aleaNegatifs	0.63	10636
+2	42172	10000	tri_fusion	tab_alea	0.04	8228
+2	42172	10000	tri_fusion	tab_trie	0.05	8308
+2	42172	10000	tri_fusion	tab_triInverse	0.06	8328
+2	42172	10000	tri_fusion	tab_constant	0.05	8316
+2	42172	10000	tri_fusion	tab_aleaNegatifs	0.04	8244
+2	42172	10000	tri_fusion_opti	tab_alea	0.05	2120
+2	42172	10000	tri_fusion_opti	tab_trie	0.06	1988
+2	42172	10000	tri_fusion_opti	tab_triInverse	0.06	2092
+2	42172	10000	tri_fusion_opti	tab_constant	0.04	2032
+2	42172	10000	tri_fusion_opti	tab_aleaNegatifs	0.05	2176
+3	142297	10000	tri_fusion	tab_alea	0.17	26840
+3	142297	10000	tri_fusion	tab_trie	0.21	26812
+3	142297	10000	tri_fusion	tab_triInverse	0.20	26792
+3	142297	10000	tri_fusion	tab_constant	0.12	26748
+3	142297	10000	tri_fusion	tab_aleaNegatifs	0.19	26916
+3	142297	10000	tri_fusion_opti	tab_alea	0.15	3728
+3	142297	10000	tri_fusion_opti	tab_trie	0.18	3740
+3	142297	10000	tri_fusion_opti	tab_triInverse	0.19	3632
+3	142297	10000	tri_fusion_opti	tab_constant	0.11	3644
+3	142297	10000	tri_fusion_opti	tab_aleaNegatifs	0.14	3632
+4	432221	10000	tri_fusion	tab_alea	0.52	83904
+4	432221	10000	tri_fusion	tab_trie	0.61	83848
+4	432221	10000	tri_fusion	tab_triInverse	0.63	83724
+4	432221	10000	tri_fusion	tab_constant	0.40	83780
+4	432221	10000	tri_fusion	tab_aleaNegatifs	0.48	83896
+4	432221	10000	tri_fusion_opti	tab_alea	0.44	8272
+4	432221	10000	tri_fusion_opti	tab_trie	0.58	8156
+4	432221	10000	tri_fusion_opti	tab_triInverse	0.55	8172
+4	432221	10000	tri_fusion_opti	tab_constant	0.36	8216
+4	432221	10000	tri_fusion_opti	tab_aleaNegatifs	0.46	8148
+5	772905	10000	tri_fusion	tab_alea	0.92	153968
+5	772905	10000	tri_fusion	tab_trie	1.14	153924
+5	772905	10000	tri_fusion	tab_triInverse	1.15	153868
+5	772905	10000	tri_fusion	tab_constant	0.82	153980
+5	772905	10000	tri_fusion	tab_aleaNegatifs	0.89	154088
+5	772905	10000	tri_fusion_opti	tab_alea	0.80	13420
+5	772905	10000	tri_fusion_opti	tab_trie	1.06	13592
+5	772905	10000	tri_fusion_opti	tab_triInverse	1.00	13492
+5	772905	10000	tri_fusion_opti	tab_constant	0.65	13592
+5	772905	10000	tri_fusion_opti	tab_aleaNegatifs	0.80	13464
+6	241193	10000	tri_fusion	tab_alea	0.27	45944
+6	241193	10000	tri_fusion	tab_trie	0.34	46088
+6	241193	10000	tri_fusion	tab_triInverse	0.33	45952
+6	241193	10000	tri_fusion	tab_constant	0.22	46000
+6	241193	10000	tri_fusion	tab_aleaNegatifs	0.29	45964
+6	241193	10000	tri_fusion_opti	tab_alea	0.23	5280
+6	241193	10000	tri_fusion_opti	tab_trie	0.31	5156
+6	241193	10000	tri_fusion_opti	tab_triInverse	0.30	5100
+6	241193	10000	tri_fusion_opti	tab_constant	0.19	5292
+6	241193	10000	tri_fusion_opti	tab_aleaNegatifs	0.24	5272
+7	452255	10000	tri_fusion	tab_alea	0.48	88136
+7	452255	10000	tri_fusion	tab_trie	0.65	88056
+7	452255	10000	tri_fusion	tab_triInverse	0.65	87948
+7	452255	10000	tri_fusion	tab_constant	0.45	88020
+7	452255	10000	tri_fusion	tab_aleaNegatifs	0.51	88144
+7	452255	10000	tri_fusion_opti	tab_alea	0.47	8456
+7	452255	10000	tri_fusion_opti	tab_trie	0.61	8616
+7	452255	10000	tri_fusion_opti	tab_triInverse	0.58	8616
+7	452255	10000	tri_fusion_opti	tab_constant	0.40	8580
+7	452255	10000	tri_fusion_opti	tab_aleaNegatifs	0.47	8400
+8	463732	10000	tri_fusion	tab_alea	0.58	90400
+8	463732	10000	tri_fusion	tab_trie	0.71	90420
+8	463732	10000	tri_fusion	tab_triInverse	0.67	90384
+8	463732	10000	tri_fusion	tab_constant	0.46	90372
+8	463732	10000	tri_fusion	tab_aleaNegatifs	0.53	90560
+8	463732	10000	tri_fusion_opti	tab_alea	0.47	8576
+8	463732	10000	tri_fusion_opti	tab_trie	0.61	8740
+8	463732	10000	tri_fusion_opti	tab_triInverse	0.59	8656
+8	463732	10000	tri_fusion_opti	tab_constant	0.39	8664
+8	463732	10000	tri_fusion_opti	tab_aleaNegatifs	0.46	8704
+9	849540	10000	tri_fusion	tab_alea	0.95	169840
+9	849540	10000	tri_fusion	tab_trie	1.26	169780
+9	849540	10000	tri_fusion	tab_triInverse	1.19	169892
+9	849540	10000	tri_fusion	tab_constant	0.85	169952
+9	849540	10000	tri_fusion	tab_aleaNegatifs	1.01	169820
+9	849540	10000	tri_fusion_opti	tab_alea	0.89	14660
+9	849540	10000	tri_fusion_opti	tab_trie	1.19	14588
+9	849540	10000	tri_fusion_opti	tab_triInverse	1.12	14684
+9	849540	10000	tri_fusion_opti	tab_constant	0.73	14676
+9	849540	10000	tri_fusion_opti	tab_aleaNegatifs	0.91	14648
+10	472468	10000	tri_fusion	tab_alea	0.58	92180
+10	472468	10000	tri_fusion	tab_trie	0.67	92176
+10	472468	10000	tri_fusion	tab_triInverse	0.68	92216
+10	472468	10000	tri_fusion	tab_constant	0.48	92344
+10	472468	10000	tri_fusion	tab_aleaNegatifs	0.54	92224
+10	472468	10000	tri_fusion_opti	tab_alea	0.50	8784
+10	472468	10000	tri_fusion_opti	tab_trie	0.63	8796
+10	472468	10000	tri_fusion_opti	tab_triInverse	0.64	8800
+10	472468	10000	tri_fusion_opti	tab_constant	0.41	8700
+10	472468	10000	tri_fusion_opti	tab_aleaNegatifs	0.54	8696
+11	281710	10000	tri_fusion	tab_alea	0.35	53960
+11	281710	10000	tri_fusion	tab_trie	0.41	53884
+11	281710	10000	tri_fusion	tab_triInverse	0.43	54004
+11	281710	10000	tri_fusion	tab_constant	0.28	53956
+11	281710	10000	tri_fusion	tab_aleaNegatifs	0.35	54080
+11	281710	10000	tri_fusion_opti	tab_alea	0.29	5792
+11	281710	10000	tri_fusion_opti	tab_trie	0.37	5788
+11	281710	10000	tri_fusion_opti	tab_triInverse	0.35	5900
+11	281710	10000	tri_fusion_opti	tab_constant	0.23	5816
+11	281710	10000	tri_fusion_opti	tab_aleaNegatifs	0.28	5792
+12	830572	10000	tri_fusion	tab_alea	0.93	165772
+12	830572	10000	tri_fusion	tab_trie	1.22	165836
+12	830572	10000	tri_fusion	tab_triInverse	1.18	165800
+12	830572	10000	tri_fusion	tab_constant	0.89	165880
+12	830572	10000	tri_fusion	tab_aleaNegatifs	1.00	165744
+12	830572	10000	tri_fusion_opti	tab_alea	0.88	14504
+12	830572	10000	tri_fusion_opti	tab_trie	1.18	14308
+12	830572	10000	tri_fusion_opti	tab_triInverse	1.10	14288
+12	830572	10000	tri_fusion_opti	tab_constant	0.71	14372
+12	830572	10000	tri_fusion_opti	tab_aleaNegatifs	0.85	14496
+13	875184	10000	tri_fusion	tab_alea	1.05	175328
+13	875184	10000	tri_fusion	tab_trie	1.28	175124
+13	875184	10000	tri_fusion	tab_triInverse	1.26	175196
+13	875184	10000	tri_fusion	tab_constant	0.87	175216
+13	875184	10000	tri_fusion	tab_aleaNegatifs	1.07	175304
+13	875184	10000	tri_fusion_opti	tab_alea	0.88	14992
+13	875184	10000	tri_fusion_opti	tab_trie	1.15	15104
+13	875184	10000	tri_fusion_opti	tab_triInverse	1.12	15092
+13	875184	10000	tri_fusion_opti	tab_constant	0.73	15176
+13	875184	10000	tri_fusion_opti	tab_aleaNegatifs	0.91	15192
+14	366061	10000	tri_fusion	tab_alea	0.40	70336
+14	366061	10000	tri_fusion	tab_trie	0.51	70412
+14	366061	10000	tri_fusion	tab_triInverse	0.51	70212
+14	366061	10000	tri_fusion	tab_constant	0.35	70260
+14	366061	10000	tri_fusion	tab_aleaNegatifs	0.43	70468
+14	366061	10000	tri_fusion_opti	tab_alea	0.37	7140
+14	366061	10000	tri_fusion_opti	tab_trie	0.47	7116
+14	366061	10000	tri_fusion_opti	tab_triInverse	0.47	7152
+14	366061	10000	tri_fusion_opti	tab_constant	0.29	7236
+14	366061	10000	tri_fusion_opti	tab_aleaNegatifs	0.35	7136
+15	436837	10000	tri_fusion	tab_alea	0.48	84736
+15	436837	10000	tri_fusion	tab_trie	0.65	84676
+15	436837	10000	tri_fusion	tab_triInverse	0.62	84584
+15	436837	10000	tri_fusion	tab_constant	0.46	84852
+15	436837	10000	tri_fusion	tab_aleaNegatifs	0.52	84836
+15	436837	10000	tri_fusion_opti	tab_alea	0.44	8248
+15	436837	10000	tri_fusion_opti	tab_trie	0.58	8236
+15	436837	10000	tri_fusion_opti	tab_triInverse	0.56	8352
+15	436837	10000	tri_fusion_opti	tab_constant	0.38	8216
+15	436837	10000	tri_fusion_opti	tab_aleaNegatifs	0.45	8328
+16	778026	10000	tri_fusion	tab_alea	0.94	155088
+16	778026	10000	tri_fusion	tab_trie	1.16	155020
+16	778026	10000	tri_fusion	tab_triInverse	1.14	154940
+16	778026	10000	tri_fusion	tab_constant	0.78	155200
+16	778026	10000	tri_fusion	tab_aleaNegatifs	0.90	155068
+16	778026	10000	tri_fusion_opti	tab_alea	0.80	13488
+16	778026	10000	tri_fusion_opti	tab_trie	1.07	13552
+16	778026	10000	tri_fusion_opti	tab_triInverse	1.01	13560
+16	778026	10000	tri_fusion_opti	tab_constant	0.68	13528
+16	778026	10000	tri_fusion_opti	tab_aleaNegatifs	0.81	13560
+17	90963	10000	tri_fusion	tab_alea	0.09	17032
+17	90963	10000	tri_fusion	tab_trie	0.12	17084
+17	90963	10000	tri_fusion	tab_triInverse	0.13	17012
+17	90963	10000	tri_fusion	tab_constant	0.08	17212
+17	90963	10000	tri_fusion	tab_aleaNegatifs	0.10	17132
+17	90963	10000	tri_fusion_opti	tab_alea	0.08	2940
+17	90963	10000	tri_fusion_opti	tab_trie	0.12	2924
+17	90963	10000	tri_fusion_opti	tab_triInverse	0.11	2920
+17	90963	10000	tri_fusion_opti	tab_constant	0.07	2768
+17	90963	10000	tri_fusion_opti	tab_aleaNegatifs	0.09	2880
+18	70152	10000	tri_fusion	tab_alea	0.07	13416
+18	70152	10000	tri_fusion	tab_trie	0.09	13484
+18	70152	10000	tri_fusion	tab_triInverse	0.08	13504
+18	70152	10000	tri_fusion	tab_constant	0.06	13504
+18	70152	10000	tri_fusion	tab_aleaNegatifs	0.09	13416
+18	70152	10000	tri_fusion_opti	tab_alea	0.07	2504
+18	70152	10000	tri_fusion_opti	tab_trie	0.09	2604
+18	70152	10000	tri_fusion_opti	tab_triInverse	0.09	2532
+18	70152	10000	tri_fusion_opti	tab_constant	0.05	2620
+18	70152	10000	tri_fusion_opti	tab_aleaNegatifs	0.06	2528
+19	421428	10000	tri_fusion	tab_alea	0.47	81720
+19	421428	10000	tri_fusion	tab_trie	0.63	81568
+19	421428	10000	tri_fusion	tab_triInverse	0.62	81568
+19	421428	10000	tri_fusion	tab_constant	0.41	81528
+19	421428	10000	tri_fusion	tab_aleaNegatifs	0.49	81524
+19	421428	10000	tri_fusion_opti	tab_alea	0.43	8012
+19	421428	10000	tri_fusion_opti	tab_trie	0.56	7992
+19	421428	10000	tri_fusion_opti	tab_triInverse	0.53	8012
+19	421428	10000	tri_fusion_opti	tab_constant	0.36	7976
+19	421428	10000	tri_fusion_opti	tab_aleaNegatifs	0.44	8000
+20	356529	10000	tri_fusion	tab_alea	0.39	68444
+20	356529	10000	tri_fusion	tab_trie	0.54	68380
+20	356529	10000	tri_fusion	tab_triInverse	0.46	68488
+20	356529	10000	tri_fusion	tab_constant	0.35	68444
+20	356529	10000	tri_fusion	tab_aleaNegatifs	0.41	68564
+20	356529	10000	tri_fusion_opti	tab_alea	0.35	6904
+20	356529	10000	tri_fusion_opti	tab_trie	0.46	7080
+20	356529	10000	tri_fusion_opti	tab_triInverse	0.48	6900
+20	356529	10000	tri_fusion_opti	tab_constant	0.30	6888
+20	356529	10000	tri_fusion_opti	tab_aleaNegatifs	0.39	6992
+21	449665	10000	tri_fusion	tab_alea	0.53	87364
+21	449665	10000	tri_fusion	tab_trie	0.68	87384
+21	449665	10000	tri_fusion	tab_triInverse	0.64	87324
+21	449665	10000	tri_fusion	tab_constant	0.46	87544
+21	449665	10000	tri_fusion	tab_aleaNegatifs	0.54	87420
+21	449665	10000	tri_fusion_opti	tab_alea	0.45	8516
+21	449665	10000	tri_fusion_opti	tab_trie	0.61	8484
+21	449665	10000	tri_fusion_opti	tab_triInverse	0.60	8412
+21	449665	10000	tri_fusion_opti	tab_constant	0.39	8528
+21	449665	10000	tri_fusion_opti	tab_aleaNegatifs	0.45	8416
+22	925156	10000	tri_fusion	tab_alea	1.11	186352
+22	925156	10000	tri_fusion	tab_trie	1.41	186084
+22	925156	10000	tri_fusion	tab_triInverse	1.38	186196
+22	925156	10000	tri_fusion	tab_constant	0.86	186228
+22	925156	10000	tri_fusion	tab_aleaNegatifs	1.14	186268
+22	925156	10000	tri_fusion_opti	tab_alea	0.93	15772
+22	925156	10000	tri_fusion_opti	tab_trie	1.25	15856
+22	925156	10000	tri_fusion_opti	tab_triInverse	1.29	15844
+22	925156	10000	tri_fusion_opti	tab_constant	0.78	15980
+22	925156	10000	tri_fusion_opti	tab_aleaNegatifs	1.06	15856
+23	128532	10000	tri_fusion	tab_alea	0.14	24484
+23	128532	10000	tri_fusion	tab_trie	0.18	24476
+23	128532	10000	tri_fusion	tab_triInverse	0.18	24308
+23	128532	10000	tri_fusion	tab_constant	0.10	24324
+23	128532	10000	tri_fusion	tab_aleaNegatifs	0.13	24476
+23	128532	10000	tri_fusion_opti	tab_alea	0.13	3356
+23	128532	10000	tri_fusion_opti	tab_trie	0.16	3324
+23	128532	10000	tri_fusion_opti	tab_triInverse	0.16	3428
+23	128532	10000	tri_fusion_opti	tab_constant	0.10	3532
+23	128532	10000	tri_fusion_opti	tab_aleaNegatifs	0.12	3344
+24	217373	10000	tri_fusion	tab_alea	0.25	41120
+24	217373	10000	tri_fusion	tab_trie	0.35	41244
+24	217373	10000	tri_fusion	tab_triInverse	0.31	41128
+24	217373	10000	tri_fusion	tab_constant	0.21	41092
+24	217373	10000	tri_fusion	tab_aleaNegatifs	0.24	41168
+24	217373	10000	tri_fusion_opti	tab_alea	0.24	4896
+24	217373	10000	tri_fusion_opti	tab_trie	0.29	4812
+24	217373	10000	tri_fusion_opti	tab_triInverse	0.27	4712
+24	217373	10000	tri_fusion_opti	tab_constant	0.18	4824
+24	217373	10000	tri_fusion_opti	tab_aleaNegatifs	0.22	4920
+25	558552	10000	tri_fusion	tab_alea	0.66	110092
+25	558552	10000	tri_fusion	tab_trie	0.81	110040
+25	558552	10000	tri_fusion	tab_triInverse	0.82	110048
+25	558552	10000	tri_fusion	tab_constant	0.56	110148
+25	558552	10000	tri_fusion	tab_aleaNegatifs	0.65	110092
+25	558552	10000	tri_fusion_opti	tab_alea	0.56	10128
+25	558552	10000	tri_fusion_opti	tab_trie	0.75	10236
+25	558552	10000	tri_fusion_opti	tab_triInverse	0.73	10132
+25	558552	10000	tri_fusion_opti	tab_constant	0.48	10144
+25	558552	10000	tri_fusion_opti	tab_aleaNegatifs	0.54	10132
+26	814680	10000	tri_fusion	tab_alea	0.98	162540
+26	814680	10000	tri_fusion	tab_trie	1.23	162560
+26	814680	10000	tri_fusion	tab_triInverse	1.20	162512
+26	814680	10000	tri_fusion	tab_constant	0.84	162620
+26	814680	10000	tri_fusion	tab_aleaNegatifs	0.99	162544
+26	814680	10000	tri_fusion_opti	tab_alea	0.87	14104
+26	814680	10000	tri_fusion_opti	tab_trie	1.11	14060
+26	814680	10000	tri_fusion_opti	tab_triInverse	1.12	14244
+26	814680	10000	tri_fusion_opti	tab_constant	0.70	14236
+26	814680	10000	tri_fusion_opti	tab_aleaNegatifs	0.87	14064
+27	213980	10000	tri_fusion	tab_alea	0.26	40508
+27	213980	10000	tri_fusion	tab_trie	0.32	40512
+27	213980	10000	tri_fusion	tab_triInverse	0.32	40480
+27	213980	10000	tri_fusion	tab_constant	0.22	40572
+27	213980	10000	tri_fusion	tab_aleaNegatifs	0.24	40532
+27	213980	10000	tri_fusion_opti	tab_alea	0.21	4672
+27	213980	10000	tri_fusion_opti	tab_trie	0.29	4840
+27	213980	10000	tri_fusion_opti	tab_triInverse	0.27	4768
+27	213980	10000	tri_fusion_opti	tab_constant	0.17	4772
+27	213980	10000	tri_fusion_opti	tab_aleaNegatifs	0.23	4672
+28	957397	10000	tri_fusion	tab_alea	1.12	193188
+28	957397	10000	tri_fusion	tab_trie	1.43	193200
+28	957397	10000	tri_fusion	tab_triInverse	1.50	193076
+28	957397	10000	tri_fusion	tab_constant	0.96	193304
+28	957397	10000	tri_fusion	tab_aleaNegatifs	1.12	193288
+28	957397	10000	tri_fusion_opti	tab_alea	1.00	16292
+28	957397	10000	tri_fusion_opti	tab_trie	1.24	16556
+28	957397	10000	tri_fusion_opti	tab_triInverse	1.30	16364
+28	957397	10000	tri_fusion_opti	tab_constant	0.83	16416
+28	957397	10000	tri_fusion_opti	tab_aleaNegatifs	1.02	16348
+29	701849	10000	tri_fusion	tab_alea	0.82	138528
+29	701849	10000	tri_fusion	tab_trie	1.06	138676
+29	701849	10000	tri_fusion	tab_triInverse	1.02	138532
+29	701849	10000	tri_fusion	tab_constant	0.71	138592
+29	701849	10000	tri_fusion	tab_aleaNegatifs	0.83	138620
+29	701849	10000	tri_fusion_opti	tab_alea	0.82	12284
+29	701849	10000	tri_fusion_opti	tab_trie	0.99	12396
+29	701849	10000	tri_fusion_opti	tab_triInverse	0.97	12484
+29	701849	10000	tri_fusion_opti	tab_constant	0.62	12396
+29	701849	10000	tri_fusion_opti	tab_aleaNegatifs	0.73	12368
+30	71943	10000	tri_fusion	tab_alea	0.07	13812
+30	71943	10000	tri_fusion	tab_trie	0.10	13688
+30	71943	10000	tri_fusion	tab_triInverse	0.10	13680
+30	71943	10000	tri_fusion	tab_constant	0.06	13668
+30	71943	10000	tri_fusion	tab_aleaNegatifs	0.09	13692
+30	71943	10000	tri_fusion_opti	tab_alea	0.06	2528
+30	71943	10000	tri_fusion_opti	tab_trie	0.09	2540
+30	71943	10000	tri_fusion_opti	tab_triInverse	0.08	2584
+30	71943	10000	tri_fusion_opti	tab_constant	0.05	2632
+30	71943	10000	tri_fusion_opti	tab_aleaNegatifs	0.07	2512
+31	354817	10000	tri_fusion	tab_alea	0.40	68076
+31	354817	10000	tri_fusion	tab_trie	0.54	68012
+31	354817	10000	tri_fusion	tab_triInverse	0.48	68108
+31	354817	10000	tri_fusion	tab_constant	0.35	68072
+31	354817	10000	tri_fusion	tab_aleaNegatifs	0.42	68096
+31	354817	10000	tri_fusion_opti	tab_alea	0.37	7048
+31	354817	10000	tri_fusion_opti	tab_trie	0.45	6932
+31	354817	10000	tri_fusion_opti	tab_triInverse	0.41	6928
+31	354817	10000	tri_fusion_opti	tab_constant	0.33	6960
+31	354817	10000	tri_fusion_opti	tab_aleaNegatifs	0.40	7008
+32	718530	10000	tri_fusion	tab_alea	0.86	142220
+32	718530	10000	tri_fusion	tab_trie	1.03	142124
+32	718530	10000	tri_fusion	tab_triInverse	1.06	142120
+32	718530	10000	tri_fusion	tab_constant	0.69	142300
+32	718530	10000	tri_fusion	tab_aleaNegatifs	0.84	142164
+32	718530	10000	tri_fusion_opti	tab_alea	0.77	12728
+32	718530	10000	tri_fusion_opti	tab_trie	0.98	12724
+32	718530	10000	tri_fusion_opti	tab_triInverse	0.92	12628
+32	718530	10000	tri_fusion_opti	tab_constant	0.61	12544
+32	718530	10000	tri_fusion_opti	tab_aleaNegatifs	0.79	12628
+33	750283	10000	tri_fusion	tab_alea	0.88	148924
+33	750283	10000	tri_fusion	tab_trie	1.14	148728
+33	750283	10000	tri_fusion	tab_triInverse	1.14	148872
+33	750283	10000	tri_fusion	tab_constant	0.78	148896
+33	750283	10000	tri_fusion	tab_aleaNegatifs	0.94	148848
+33	750283	10000	tri_fusion_opti	tab_alea	0.78	13136
+33	750283	10000	tri_fusion_opti	tab_trie	1.02	13160
+33	750283	10000	tri_fusion_opti	tab_triInverse	0.99	13240
+33	750283	10000	tri_fusion_opti	tab_constant	0.69	13236
+33	750283	10000	tri_fusion_opti	tab_aleaNegatifs	0.81	13040
+34	15601	10000	tri_fusion	tab_alea	0.02	3776
+34	15601	10000	tri_fusion	tab_trie	0.02	3912
+34	15601	10000	tri_fusion	tab_triInverse	0.02	3904
+34	15601	10000	tri_fusion	tab_constant	0.02	3832
+34	15601	10000	tri_fusion	tab_aleaNegatifs	0.02	3808
+34	15601	10000	tri_fusion_opti	tab_alea	0.02	1636
+34	15601	10000	tri_fusion_opti	tab_trie	0.02	1764
+34	15601	10000	tri_fusion_opti	tab_triInverse	0.02	1668
+34	15601	10000	tri_fusion_opti	tab_constant	0.01	1556
+34	15601	10000	tri_fusion_opti	tab_aleaNegatifs	0.02	1760
+35	12155	10000	tri_fusion	tab_alea	0.01	3284
+35	12155	10000	tri_fusion	tab_trie	0.01	3216
+35	12155	10000	tri_fusion	tab_triInverse	0.00	3140
+35	12155	10000	tri_fusion	tab_constant	0.01	3256
+35	12155	10000	tri_fusion	tab_aleaNegatifs	0.01	3212
+35	12155	10000	tri_fusion_opti	tab_alea	0.01	1708
+35	12155	10000	tri_fusion_opti	tab_trie	0.01	1572
+35	12155	10000	tri_fusion_opti	tab_triInverse	0.01	1616
+35	12155	10000	tri_fusion_opti	tab_constant	0.01	1584
+35	12155	10000	tri_fusion_opti	tab_aleaNegatifs	0.01	1584
+36	119575	10000	tri_fusion	tab_alea	0.13	22608
+36	119575	10000	tri_fusion	tab_trie	0.16	22544
+36	119575	10000	tri_fusion	tab_triInverse	0.15	22524
+36	119575	10000	tri_fusion	tab_constant	0.11	22464
+36	119575	10000	tri_fusion	tab_aleaNegatifs	0.13	22556
+36	119575	10000	tri_fusion_opti	tab_alea	0.12	3212
+36	119575	10000	tri_fusion_opti	tab_trie	0.14	3372
+36	119575	10000	tri_fusion_opti	tab_triInverse	0.14	3264
+36	119575	10000	tri_fusion_opti	tab_constant	0.09	3328
+36	119575	10000	tri_fusion_opti	tab_aleaNegatifs	0.11	3300
+37	531379	10000	tri_fusion	tab_alea	0.59	105140
+37	531379	10000	tri_fusion	tab_trie	0.79	105048
+37	531379	10000	tri_fusion	tab_triInverse	0.78	104928
+37	531379	10000	tri_fusion	tab_constant	0.50	105040
+37	531379	10000	tri_fusion	tab_aleaNegatifs	0.60	105120
+37	531379	10000	tri_fusion_opti	tab_alea	0.53	9828
+37	531379	10000	tri_fusion_opti	tab_trie	0.71	9708
+37	531379	10000	tri_fusion_opti	tab_triInverse	0.69	9816
+37	531379	10000	tri_fusion_opti	tab_constant	0.44	9688
+37	531379	10000	tri_fusion_opti	tab_aleaNegatifs	0.52	9824
+38	189367	10000	tri_fusion	tab_alea	0.23	35836
+38	189367	10000	tri_fusion	tab_trie	0.26	35796
+38	189367	10000	tri_fusion	tab_triInverse	0.26	35724
+38	189367	10000	tri_fusion	tab_constant	0.20	35740
+38	189367	10000	tri_fusion	tab_aleaNegatifs	0.24	35780
+38	189367	10000	tri_fusion_opti	tab_alea	0.20	4416
+38	189367	10000	tri_fusion_opti	tab_trie	0.24	4380
+38	189367	10000	tri_fusion_opti	tab_triInverse	0.27	4388
+38	189367	10000	tri_fusion_opti	tab_constant	0.16	4332
+38	189367	10000	tri_fusion_opti	tab_aleaNegatifs	0.21	4456
+39	746604	10000	tri_fusion	tab_alea	0.90	148152
+39	746604	10000	tri_fusion	tab_trie	1.16	148004
+39	746604	10000	tri_fusion	tab_triInverse	1.10	148120
+39	746604	10000	tri_fusion	tab_constant	0.78	148144
+39	746604	10000	tri_fusion	tab_aleaNegatifs	0.91	148168
+39	746604	10000	tri_fusion_opti	tab_alea	0.86	13176
+39	746604	10000	tri_fusion_opti	tab_trie	1.09	13188
+39	746604	10000	tri_fusion_opti	tab_triInverse	1.06	13180
+39	746604	10000	tri_fusion_opti	tab_constant	0.65	13156
+39	746604	10000	tri_fusion_opti	tab_aleaNegatifs	0.83	13036
+40	245979	10000	tri_fusion	tab_alea	0.28	47076
+40	245979	10000	tri_fusion	tab_trie	0.37	47040
+40	245979	10000	tri_fusion	tab_triInverse	0.37	47008
+40	245979	10000	tri_fusion	tab_constant	0.26	47160
+40	245979	10000	tri_fusion	tab_aleaNegatifs	0.30	47064
+40	245979	10000	tri_fusion_opti	tab_alea	0.25	5268
+40	245979	10000	tri_fusion_opti	tab_trie	0.32	5252
+40	245979	10000	tri_fusion_opti	tab_triInverse	0.31	5356
+40	245979	10000	tri_fusion_opti	tab_constant	0.19	5188
+40	245979	10000	tri_fusion_opti	tab_aleaNegatifs	0.26	5352
+41	404572	10000	tri_fusion	tab_alea	0.47	78204
+41	404572	10000	tri_fusion	tab_trie	0.58	78312
+41	404572	10000	tri_fusion	tab_triInverse	0.55	78124
+41	404572	10000	tri_fusion	tab_constant	0.41	78172
+41	404572	10000	tri_fusion	tab_aleaNegatifs	0.48	78288
+41	404572	10000	tri_fusion_opti	tab_alea	0.42	7848
+41	404572	10000	tri_fusion_opti	tab_trie	0.51	7712
+41	404572	10000	tri_fusion_opti	tab_triInverse	0.52	7748
+41	404572	10000	tri_fusion_opti	tab_constant	0.32	7848
+41	404572	10000	tri_fusion_opti	tab_aleaNegatifs	0.41	7736
+42	904681	10000	tri_fusion	tab_alea	1.09	181736
+42	904681	10000	tri_fusion	tab_trie	1.33	181744
+42	904681	10000	tri_fusion	tab_triInverse	1.30	181724
+42	904681	10000	tri_fusion	tab_constant	0.85	181868
+42	904681	10000	tri_fusion	tab_aleaNegatifs	1.00	181876
+42	904681	10000	tri_fusion_opti	tab_alea	0.90	15528
+42	904681	10000	tri_fusion_opti	tab_trie	1.18	15528
+42	904681	10000	tri_fusion_opti	tab_triInverse	1.20	15652
+42	904681	10000	tri_fusion_opti	tab_constant	0.76	15504
+42	904681	10000	tri_fusion_opti	tab_aleaNegatifs	0.98	15592
+43	792901	10000	tri_fusion	tab_alea	0.97	158284
+43	792901	10000	tri_fusion	tab_trie	1.14	158232
+43	792901	10000	tri_fusion	tab_triInverse	1.12	158272
+43	792901	10000	tri_fusion	tab_constant	0.83	158304
+43	792901	10000	tri_fusion	tab_aleaNegatifs	1.00	158300
+43	792901	10000	tri_fusion_opti	tab_alea	0.83	13904
+43	792901	10000	tri_fusion_opti	tab_trie	1.08	13812
+43	792901	10000	tri_fusion_opti	tab_triInverse	1.03	13912
+43	792901	10000	tri_fusion_opti	tab_constant	0.66	13780
+43	792901	10000	tri_fusion_opti	tab_aleaNegatifs	0.87	13912
+44	461908	10000	tri_fusion	tab_alea	0.61	90196
+44	461908	10000	tri_fusion	tab_trie	0.68	90160
+44	461908	10000	tri_fusion	tab_triInverse	0.67	90064
+44	461908	10000	tri_fusion	tab_constant	0.48	90100
+44	461908	10000	tri_fusion	tab_aleaNegatifs	0.56	90012
+44	461908	10000	tri_fusion_opti	tab_alea	0.53	8640
+44	461908	10000	tri_fusion_opti	tab_trie	0.62	8548
+44	461908	10000	tri_fusion_opti	tab_triInverse	0.61	8608
+44	461908	10000	tri_fusion_opti	tab_constant	0.39	8552
+44	461908	10000	tri_fusion_opti	tab_aleaNegatifs	0.46	8592
+45	852371	10000	tri_fusion	tab_alea	1.01	170640
+45	852371	10000	tri_fusion	tab_trie	1.29	170484
+45	852371	10000	tri_fusion	tab_triInverse	1.27	170528
+45	852371	10000	tri_fusion	tab_constant	0.87	170716
+45	852371	10000	tri_fusion	tab_aleaNegatifs	1.00	170644
+45	852371	10000	tri_fusion_opti	tab_alea	0.87	14736
+45	852371	10000	tri_fusion_opti	tab_trie	1.10	14836
+45	852371	10000	tri_fusion_opti	tab_triInverse	1.11	14708
+45	852371	10000	tri_fusion_opti	tab_constant	0.71	14660
+45	852371	10000	tri_fusion_opti	tab_aleaNegatifs	0.99	14732
+46	442223	10000	tri_fusion	tab_alea	0.48	85872
+46	442223	10000	tri_fusion	tab_trie	0.65	85852
+46	442223	10000	tri_fusion	tab_triInverse	0.62	85756
+46	442223	10000	tri_fusion	tab_constant	0.44	85960
+46	442223	10000	tri_fusion	tab_aleaNegatifs	0.52	85832
+46	442223	10000	tri_fusion_opti	tab_alea	0.44	8312
+46	442223	10000	tri_fusion_opti	tab_trie	0.55	8316
+46	442223	10000	tri_fusion_opti	tab_triInverse	0.54	8416
+46	442223	10000	tri_fusion_opti	tab_constant	0.39	8224
+46	442223	10000	tri_fusion_opti	tab_aleaNegatifs	0.45	8296
+47	491318	10000	tri_fusion	tab_alea	0.57	96296
+47	491318	10000	tri_fusion	tab_trie	0.70	96316
+47	491318	10000	tri_fusion	tab_triInverse	0.72	96340
+47	491318	10000	tri_fusion	tab_constant	0.46	96296
+47	491318	10000	tri_fusion	tab_aleaNegatifs	0.56	96296
+47	491318	10000	tri_fusion_opti	tab_alea	0.51	9192
+47	491318	10000	tri_fusion_opti	tab_trie	0.65	9112
+47	491318	10000	tri_fusion_opti	tab_triInverse	0.64	9100
+47	491318	10000	tri_fusion_opti	tab_constant	0.40	9200
+47	491318	10000	tri_fusion_opti	tab_aleaNegatifs	0.52	9180
+48	575349	10000	tri_fusion	tab_alea	0.72	113308
+48	575349	10000	tri_fusion	tab_trie	0.84	113204
+48	575349	10000	tri_fusion	tab_triInverse	0.81	113128
+48	575349	10000	tri_fusion	tab_constant	0.53	113268
+48	575349	10000	tri_fusion	tab_aleaNegatifs	0.67	113248
+48	575349	10000	tri_fusion_opti	tab_alea	0.62	10408
+48	575349	10000	tri_fusion_opti	tab_trie	0.76	10488
+48	575349	10000	tri_fusion_opti	tab_triInverse	0.72	10372
+48	575349	10000	tri_fusion_opti	tab_constant	0.52	10516
+48	575349	10000	tri_fusion_opti	tab_aleaNegatifs	0.59	10380
+49	837928	10000	tri_fusion	tab_alea	0.94	167540
+49	837928	10000	tri_fusion	tab_trie	1.19	167240
+49	837928	10000	tri_fusion	tab_triInverse	1.17	167240
+49	837928	10000	tri_fusion	tab_constant	0.84	167436
+49	837928	10000	tri_fusion	tab_aleaNegatifs	0.97	167444
+49	837928	10000	tri_fusion_opti	tab_alea	0.89	14424
+49	837928	10000	tri_fusion_opti	tab_trie	1.14	14500
+49	837928	10000	tri_fusion_opti	tab_triInverse	1.12	14596
+49	837928	10000	tri_fusion_opti	tab_constant	0.74	14600
+49	837928	10000	tri_fusion_opti	tab_aleaNegatifs	0.88	14480
+50	350000	10000	tri_fusion	tab_alea	0.39	67056
+50	350000	10000	tri_fusion	tab_trie	0.49	67036
+50	350000	10000	tri_fusion	tab_triInverse	0.52	67056
+50	350000	10000	tri_fusion	tab_constant	0.36	67184
+50	350000	10000	tri_fusion	tab_aleaNegatifs	0.40	67016
+50	350000	10000	tri_fusion_opti	tab_alea	0.39	6804
+50	350000	10000	tri_fusion_opti	tab_trie	0.48	6980
+50	350000	10000	tri_fusion_opti	tab_triInverse	0.47	6940
+50	350000	10000	tri_fusion_opti	tab_constant	0.28	6976
+50	350000	10000	tri_fusion_opti	tab_aleaNegatifs	0.34	6976
diff --git a/TP3/perfHyp.sh b/TP3/perfHyp.sh
new file mode 100644
index 0000000000000000000000000000000000000000..868e59d624802b308e0726cae6a423f2f1cc0d7f
--- /dev/null
+++ b/TP3/perfHyp.sh
@@ -0,0 +1,35 @@
+#!bin/bash
+
+echo "nTest\ttaille\tmax\ttypeTri\ttypeTableau\ttemps\tmemoire"
+
+max=10000
+TYPETRITAB="${TYPETRITAB} tri_fusion"
+TYPETRITAB="${TYPETRITAB} tri_fusion_opti"
+compteurTypeTri=2
+
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_alea"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_trie"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_triInverse"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_constant"
+TYPETABLEAUTAB="${TYPETABLEAUTAB} tab_aleaNegatifs"
+compteurTypeTableau=0
+
+for nTest in `seq 1 50`
+do
+  compteurTypeTri=2
+
+  taille=$(( `od -An -N4 -tu < /dev/urandom` % 1000000))
+  for TYPETRI in ${TYPETRITAB}
+  do
+    compteurTypeTableau=0  #On réinitialise la valeur du tab, pour jamais être au dessus de 3
+
+    for TYPETABLEAU in ${TYPETABLEAUTAB}
+    do
+        compteurTypeTableau=$((compteurTypeTableau + 1))
+
+        res=`(/usr/bin/time -f "%U\t%M" ./main $taille $max $compteurTypeTri $compteurTypeTableau > /dev/null) 2>&1`
+        echo "$nTest\t$taille\t$max\t${TYPETRI}\t${TYPETABLEAU}\t$res"
+    done
+      compteurTypeTri=5 #On incrémente valeur pour lancer main
+  done
+done
diff --git a/TP3/tri_bulle.c b/TP3/tri_bulle.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd602adb6df796b2dc3aa2726126b7574080989c
--- /dev/null
+++ b/TP3/tri_bulle.c
@@ -0,0 +1,31 @@
+#include "tri_bulle.h"
+#include "function.h"
+
+struct compteur cptb;
+
+void triBulle(long tab[], size_t taille)
+{
+
+	uint8_t tri = 1;
+
+	while (tri == 1)
+	{
+		/* Supposons le tableau ordonné */
+		tri = 0;
+		/* Vérification des éléments des places j et j+1 */
+		for (int j = 0; j < taille-1; j++)
+		{
+			/* Si les 2 éléments sont mal triés */
+			if(tab[j] > tab[j+1])
+			{
+				/* Inversion des 2 éléments */
+ 				int tmp = tab[j+1];
+ 				tab[j+1] = tab[j];
+ 				tab[j] = tmp;
+
+ 				/* Le tableau n'est toujours pas trié */
+				tri = 1;
+ 			}
+		}
+	}
+}
diff --git a/TP3/tri_bulle.h b/TP3/tri_bulle.h
new file mode 100644
index 0000000000000000000000000000000000000000..76454aadd981d80ff894740f713ae86d949087fb
--- /dev/null
+++ b/TP3/tri_bulle.h
@@ -0,0 +1,6 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void triBulle(long tab[], size_t taille);
diff --git a/TP3/tri_fusion.c b/TP3/tri_fusion.c
new file mode 100644
index 0000000000000000000000000000000000000000..3bbe36c2dffbbf3d0374921b4870b457646579e0
--- /dev/null
+++ b/TP3/tri_fusion.c
@@ -0,0 +1,75 @@
+#include "tri_fusion.h"
+#include "function.h"
+#include <stdlib.h>
+
+struct compteur cptf;
+
+void sousTriFusion(long tab[], size_t p, size_t r){
+  if(p < r - 1){
+    size_t q = (p + r)/2;
+    sousTriFusion(tab, p, q);
+    sousTriFusion(tab, q, r);
+    fusion(tab, p, q, r);
+    compter(&cptf.fusion);
+  }
+}
+
+void fusion(long tab[], size_t p, size_t q, size_t r){
+  size_t n1 = q - p;
+  size_t n2 = r - q;
+
+  long *tabG;
+  long *tabD;
+  //memset(tabD, 0, n1*sizeof(long));
+  //memset(tabG, 0, n2*sizeof(long));
+  tabG = (long *) malloc(n1*sizeof(long));
+  tabD = (long *) malloc(n2*sizeof(long));
+
+
+  size_t j = 0;
+  for(size_t i = p; i < q; i++) {
+    tabG[j] = tab[i];
+    j++;
+    compter(&cptf.ecriture);
+  }
+  j = 0;
+  for(size_t i = q; i < r; i++){
+    tabD[j] = tab[i];
+    j++;
+    compter(&cptf.ecriture);
+  }
+
+  size_t indG = 0;
+  size_t indD = 0;
+  size_t i = p;
+
+  while(i < r){
+    if(indG == n1){
+      compter(&cptf.comparaison);
+      tab[i] = tabD[indD];
+      indD++;
+    }
+    else if(indD == n2){
+      compter(&cptf.comparaison);
+      tab[i] = tabG[indG];
+      indG++;
+    }
+    else if(tabG[indG] < tabD[indD]){
+      compter(&cptf.comparaison);
+      tab[i] = tabG[indG];
+      indG++;
+    }
+    else{
+      tab[i] = tabD[indD];
+      indD++;
+    }
+    i++;
+    compter(&cptf.ecriture);
+  }
+}
+
+void triFusion(long tab[], size_t taille){
+  printf("--- Lancement d'un tri fusion ! ---\n");
+  sousTriFusion(tab, 0, taille);
+  affiche_infos(cptf);
+}
diff --git a/TP3/tri_fusion.h b/TP3/tri_fusion.h
new file mode 100644
index 0000000000000000000000000000000000000000..39c647103d42df0bc59c3ea55877c87962709bb6
--- /dev/null
+++ b/TP3/tri_fusion.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void sousTriFusion(long tab[], size_t p, size_t r);
+void fusion(long tab[], size_t p, size_t q, size_t r);
+void triFusion(long tab[], size_t taille);
diff --git a/TP3/tri_fusion_opti.c b/TP3/tri_fusion_opti.c
new file mode 100644
index 0000000000000000000000000000000000000000..80884d6554ea3a5556031bd072d8e7fce76f52c3
--- /dev/null
+++ b/TP3/tri_fusion_opti.c
@@ -0,0 +1,68 @@
+#include "tri_fusion_opti.h"
+#include "function.h"
+#include <stdlib.h>
+
+struct compteur cptfo;
+
+void sousTriFusionOpti(long tab[], size_t p, size_t r, long tabCopie[]){
+  if(p < r - 1){
+    size_t q = (p + r)/2;
+    sousTriFusionOpti(tab, p, q, tabCopie);
+    sousTriFusionOpti(tab, q, r, tabCopie);
+    fusionOpti(tab, p, q, r, tabCopie);
+    compter(&cptfo.fusion);
+  }
+}
+
+void fusionOpti(long tab[], size_t p, size_t q, size_t r, long tabCopie[]){
+  size_t n1 = q - p;
+  size_t n2 = r - q;
+
+  size_t j = 0;
+  for(size_t i = p; i < q; i++) {
+    tabCopie[j] = tab[i];
+    j++;
+    compter(&cptfo.ecriture);
+  }
+  j = 0;
+  for(size_t i = q; i < r; i++){
+    tabCopie[n1 + j] = tab[i];
+    j++;
+    compter(&cptfo.ecriture);
+  }
+
+  size_t indG = 0;
+  size_t indD = 0;
+  size_t i = p;
+
+  while(i < r){
+    if(indG == n1){
+      compter(&cptfo.comparaison);
+      tab[i] = tabCopie[n1 + indD];
+      indD++;
+    }
+    else if(indD == n2){
+      compter(&cptfo.comparaison);
+      tab[i] = tabCopie[indG];
+      indG++;
+    }
+    else if(tabCopie[indG] < tabCopie[n1 + indD]){
+      compter(&cptfo.comparaison);
+      tab[i] = tabCopie[indG];
+      indG++;
+    }
+    else{
+      tab[i] = tabCopie[n1 + indD];
+      indD++;
+    }
+    i++;
+    compter(&cptfo.ecriture);
+  }
+}
+
+void triFusionOpti(long tab[], size_t taille){
+  printf("--- Lancement d'un tri fusion ! ---\n");
+  long* copie = malloc(taille*sizeof(long));
+  sousTriFusionOpti(tab, 0, taille, copie);
+  affiche_infos(cptfo);
+}
diff --git a/TP3/tri_fusion_opti.h b/TP3/tri_fusion_opti.h
new file mode 100644
index 0000000000000000000000000000000000000000..287560787f7f1258b21f546985617755295458c7
--- /dev/null
+++ b/TP3/tri_fusion_opti.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void sousTriFusionOpti(long tab[], size_t p, size_t r, long tabCopie[]);
+void fusionOpti(long tab[], size_t p, size_t q, size_t r, long tabCopie[]);
+void triFusionOpti(long tab[], size_t taille);
diff --git a/TP3/tri_insertion.c b/TP3/tri_insertion.c
new file mode 100644
index 0000000000000000000000000000000000000000..cb53e927bbb6934c51c945cde4b7756cc1c6e954
--- /dev/null
+++ b/TP3/tri_insertion.c
@@ -0,0 +1,25 @@
+#include "tri_insertion.h"
+#include "function.h"
+#include <time.h>
+
+struct compteur cpt;
+
+void tri_insertion(long tabInit[], size_t tailleTab) {
+  printf("--- Lancement d'un tri insertion ! ---\n");
+
+  for(size_t i=1; i<tailleTab; i++) {
+    long clef = tabInit[i];
+    int j=i-1;
+    compter(&cpt.comparaison);
+    while(j >= 0 && tabInit[j]>clef) {
+      tabInit[j+1]=tabInit[j];
+      compter(&cpt.ecriture);
+      j=j-1;
+    }
+
+    tabInit[j+1]=clef;
+    compter(&cpt.ecriture);
+  }
+  affiche_infos(cpt);
+  printf("--- Fin du tri insertion ! ---\n");
+}
diff --git a/TP3/tri_insertion.h b/TP3/tri_insertion.h
new file mode 100644
index 0000000000000000000000000000000000000000..809c1825803e514d9feee69416af644352b0613f
--- /dev/null
+++ b/TP3/tri_insertion.h
@@ -0,0 +1,4 @@
+#define _tri_insertion_h
+#include <stdio.h>
+
+void tri_insertion(long tabInit[], size_t tailleTab);
diff --git a/TP3/tri_rapide.c b/TP3/tri_rapide.c
new file mode 100644
index 0000000000000000000000000000000000000000..db3a7cb9c713d21fd859e613610c5c1e759ffcff
--- /dev/null
+++ b/TP3/tri_rapide.c
@@ -0,0 +1,46 @@
+#include "tri_rapide.h"
+#include "function.h"
+
+struct compteur cptr;
+
+void sousTriRapide(long tab[], size_t p, size_t r){
+  size_t max = 0; max--;
+  if(r-1 != max){
+    if(p < r-1 ){
+      size_t q = partition(tab, p, r);
+      compter(&cptr.partition);
+      sousTriRapide(tab, p, q);
+      sousTriRapide(tab, q+1, r);
+    }
+  }
+}
+
+int partition(long tab[], size_t p, size_t r){
+  long pivot = tab[r - 1];
+  size_t i = p;
+
+  for(size_t j = p; j <= (r - 2); j++ ){
+    if(tab[j] <= pivot){
+      compter(&cptr.comparaison);
+      long temp = tab[j];
+      tab[j] = tab[i];
+      compter(&cptr.ecriture);
+      tab[i] = temp;
+      compter(&cptr.ecriture);
+      i++;
+    }
+  }
+  long temp = tab[i];
+  tab[i] = tab[r-1];
+  compter(&cptr.ecriture);
+  tab[r-1] = temp;
+  compter(&cptr.ecriture);
+  return i;
+
+}
+
+void triRapide(long tab[], size_t taille){
+  printf("--- Lancement d'un tri rapide ! ---\n");
+  sousTriRapide(tab, 0, taille);
+  affiche_infos(cptr);
+}
diff --git a/TP3/tri_rapide.h b/TP3/tri_rapide.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c3ddeb8aad77b4cef2ba48eddec5a0d9c895f8c
--- /dev/null
+++ b/TP3/tri_rapide.h
@@ -0,0 +1,8 @@
+#include <stdint.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+
+void sousTriRapide(long tab[], size_t p, size_t r);
+int partition(long tab[], size_t p, size_t r);
+void triRapide(long tab[], size_t taille);