Update README.md

README.md

@@ -20,7 +20,7 @@ Comme dit précédemment, l'étude portera sur les arraylist, hasmap et vector.
 
 ### Application
 
-[code source de l'application](/src)
+[code source de l'application](src/main)
 
 Pour lancer l'application : `java -jar P4a.jar <strucutre> <operation> <nombre_occurrence>`
 
@@ -107,7 +107,7 @@ importants plus la taille augmente, leurs temps sont aussi similaires. Pour l'op
 le vector sont similaires et augmentent peu contrairement à la hashmap. Quant à l'opération remplir, l'arraylist reste relativement au même temps d'exécution, on
 observe une augmentation du temps d'exécution chez le vector est la hashmap, cepedant cette augmentation est plus importante chez la hashmap.
 En terme de temps d'exécution on observe donc que l'arraylist est une structure offrant des temps faibles quant à l'accès et au remplissage, cependant pour la suppression
-la hashmap reste la structure la plus rapide ; le vector possède des temps similaire à l'arraylist.
+la hashmap reste la structure la plus rapide ; le vector possède des temps similaires à l'arraylist.
 
 Pour la consommation mémoire, on observe que la hashmap consomme le plus de mémoire et que la consommation augmente linéairement avec le nombre d'éléments.
 La consommation mémoire des deux autres structures est assez stable, elle n'augmente que très légèrement.
@@ -126,11 +126,12 @@ on ne peut pas tirer de conclusion là-dessus.
 
 Comme vu précédemment, les temps d'exécution et la consommation mémoire des arraylist et vector sont similaires.
 Or, si le nombre d'éléments dépasse la capacité de l'arraylist, elle verra sa taille augmentée de 50% contrairement à 100% pour le vector.
-C'est pourquoi, on peut poser l'hypothèse suivante : La consommation mémoire d'une arraylist est inférieure à celle d'un vector.
+C'est pourquoi, on peut poser l'hypothèse suivante : La consommation mémoire d'une arraylist est inférieure à celle d'un vector ainsi que son temps d'exécution.
 
 ### Protocole expérimental de vérification de l'hypothèse
 
 Pour ce faire, nous allons modifier le script shell afin de tester avec un nombre d'éléments plus important. Nous ne testerons pas la méthode supprimer car prenant trop de temps.
+Nous allons tester pour un nombre d'éléments variant de 100 000 à 5 000 000 avec un pas de 50 000.
 
 ```
 Suite des commandes, ou script, à exécuter pour produire les données.
@@ -141,9 +142,32 @@ r plot_approfondie.r
 ```
 
 ### Résultats expérimentaux
+#### Temps d'exécution
+
+![plot](acceder_tps_appro.png)
+![plot](remplir_tps_appro.png)
+
+#### Consommation mémoire
+
+![plot](acceder_mem_appro.png)
+![plot](remplir_mem_appro.png)
+
 
 ### Analyse des résultats expérimentaux
 
+Les courbes restent assez similaires, cependant on remarque quand même que l'accès et le remplissage avec un vector est plus rapide et consomme moins de mémoire.
+
 ### Discussion des résultats expérimentaux
 
+A la vue des courbes, on peut donc invalider l'hypothèse émise. Finalement, ce n'est pas très étonnant que les courbes soient autant similaires, les `vector` et `arraylist` sont des structures très similaires car utilisant toutes deux un `array`.
+
 ## Conclusion et travaux futurs
+
+Finalement, on remarque que suivant la structure utilisée et le type d'opération, la consommation mémoire n'est pas la même, idem pour les temps d'exécution. Il convient alors de choisr les structures utilisées en fonction des opérations qui seront les plus utilisées. Par exemple, pour des suppressions à des positions n'étant pas en queue, il est préférable d'utiliser une hashmap.
+
+Pour des travaux futurs, il serait plus intéressant de remplacer le vector par une LinkedList, afin de comparer l'arraylist et la LinkedList.
+En effet, l'ArrayList implémente une list alors que la LinkedList implémente une liste doublement liée. La différence d'implémentation permettra ainsi de faire des analyses plus intéressantes.
+
+
+
+