Exercices 1, 2 & 3

.vscode/settings.json

+{
+    "files.associations": {
+        "limits": "c",
+        "static_binary_heap.h": "c",
+        "stdio.h": "c",
+        "dynamic_binary_heap.h": "c"
+    },
+    "C_Cpp.errorSquiggles": "Disabled"
+}
\ No newline at end of file

C/Decroissant/Makefile → C/TAS_DYNAMIQUE/0-Test_Structure/Makefile

 CC= gcc
 CXXFLAGS= -Wall -ansi --pedantic -O3
 
-CPP_O_FILE = ../__src/binary_heap.o ../__src/analyzer.o main_decroissant.o
+CPP_O_FILE = ../__src/dynamic_binary_heap.o ../__src/analyzer.o main_dynamique_test_structure.o
 LIB = -lm
 
 
 all: $(CPP_O_FILE)
-	$(CC) $(CXXFLAGS) -o main_decroissant $(CPP_O_FILE) $(LIB)
+	$(CC) $(CXXFLAGS) -o main_dynamique_test_structure $(CPP_O_FILE) $(LIB)
 
 clean:
 	rm -rf ../__src/*.o
 	rm -rf *.o
 	rm -rf *~
-	rm -rf main_decroissant
+	rm -rf main_dynamique_test_structure

C/TAS_DYNAMIQUE/0-Test_Structure/main_dynamique_test_structure.c

+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include "../__src/analyzer.h"
+#include "../__src/dynamic_binary_heap.h"
+
+
+int main(int argc, char ** argv){
+    /* ENTREE DES VALURS DE L'UTILSATEUR */
+    // Vecteur des valeurs
+    int vecteur_valeur[5] = {0};
+
+    // Saisie des valeurs par l'utilisateur
+    for(int i=0; i<5 ; i++){
+
+        fflush(stdin);
+        printf("Saisissez une valeur : ");
+        scanf("%d", vecteur_valeur + i);
+    }
+
+
+    /* EXECUTION DES DIFFERENTS SCENARIOS */
+
+    // Tas Binaire MIN de taille fixe
+    binary_heap_t * h = binary_heap_create(BINARY_HEAP_MIN);
+    // Insertion d'une valeur par l'utilisateur
+    // utilisé comme booléen pour savoir si un ajout a été effectué.
+    char insertion;
+
+    // Scenario TAS MIN
+    fprintf(stdout, "---------------\n");
+    fprintf(stdout, "--- TAS MIN ---\n");
+    fprintf(stdout, "---------------\n");
+
+    // Insertion
+    for(int i=0; i<5 ; i++){
+        insertion = binary_heap_append(h, vecteur_valeur[i]);
+
+        if(!insertion){
+            fprintf(stderr, "Insertion non effectuée\n");
+
+            return EXIT_FAILURE;
+        }
+
+        print_binary_heap(h);
+    }
+
+    // Extraction
+    int element_pop;
+
+    element_pop = binary_heap_pop_min(h);
+    if(element_pop != -1){
+        fprintf(stderr, "---------- Premiere extraction : %d\n", element_pop);
+        print_binary_heap(h);
+    }
+
+    element_pop = binary_heap_pop_min(h);
+    if(element_pop != -1){
+        fprintf(stderr, "\n---------- Deuxième extraction : %d\n", element_pop);
+        print_binary_heap(h);
+        fprintf(stderr, "\n");
+    }
+
+    // Destruction
+    binary_heap_destroy(h);
+
+
+    // Tas Binaire MAX de taille fixe
+    h = binary_heap_create(BINARY_HEAP_MAX);
+    // Insertion d'une valeur par l'utilisateur
+    // utilisé comme booléen pour savoir si un ajout a été effectué.
+    insertion = FALSE;
+
+    // Scenario TAS MAX
+    fprintf(stdout, "---------------\n");
+    fprintf(stdout, "--- TAS MAX ---\n");
+    fprintf(stdout, "---------------\n");
+
+    // Insertion
+    for(int i=0; i<5 ; i++){
+        insertion = binary_heap_append(h, vecteur_valeur[i]);
+
+        if(!insertion){
+            fprintf(stderr, "Insertion non effectuée\n");
+
+            return EXIT_FAILURE;
+        }
+
+        print_binary_heap(h);
+    }
+
+    // Extraction
+    element_pop = 0;
+
+    element_pop = binary_heap_pop_max(h);
+    if(element_pop != -1){
+        fprintf(stderr, "---------- Premiere extraction : %d\n", element_pop);
+        print_binary_heap(h);
+    }
+
+    element_pop = binary_heap_pop_max(h);
+    if(element_pop != -1){
+        fprintf(stderr, "\n---------- Deuxième extraction : %d\n", element_pop);
+        print_binary_heap(h);
+        fprintf(stderr, "\n");
+    }
+    
+    // Destruction
+    binary_heap_destroy(h);
+
+    return EXIT_SUCCESS;
+}
+

C/TAS_DYNAMIQUE/1-Ajout/Aléatoire/Makefile

+CC= gcc
+CXXFLAGS= -Wall -ansi --pedantic -O3
+
+CPP_O_FILE = ../../__src/dynamic_binary_heap.o ../../__src/analyzer.o main_dynamique_ajout_aleatoire.o
+LIB = -lm
+
+
+all: $(CPP_O_FILE)
+	$(CC) $(CXXFLAGS) -o main_dynamique_ajout_aleatoire $(CPP_O_FILE) $(LIB)
+
+clean:
+	rm -rf ../../__src/*.o
+	rm -rf *.o
+	rm -rf *~
+	rm -rf main_dynamique_ajout_aleatoire
\ No newline at end of file

C/TAS_DYNAMIQUE/1-Ajout/Aléatoire/main_dynamique_ajout_aleatoire.c

+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include "../../__src/analyzer.h"
+#include "../../__src/dynamic_binary_heap.h"
+
+
+int main(int argc, char ** argv){
+    // Création d'un vecteur de valeurs aléatoirement ordonnées
+    // On adoptera le même vecteur pour les deux expériences (TAS MIN & TAS MAX)
+    srand(time(0));
+    int* random_vector = create_random_vector(BINARY_HEAP_LENGTH);
+
+    // Affichage du tableau
+    fprintf(stderr, " Random Table : ");
+    for(int indice=0;indice<BINARY_HEAP_LENGTH;indice++){
+        fprintf(stderr, " %d _", random_vector[indice]);
+    }
+    fprintf(stderr, " \n");
+
+    /* TAS BINAIRE MAX */
+    // Tas Binaire de taille fixe
+    binary_heap_t * h = binary_heap_create(BINARY_HEAP_MAX);
+    // Analyse du temps pris par les opérations.
+    analyzer_t * time_analysis = analyzer_create();
+    // Analyse des swap faits par les opérations.
+    analyzer_t * swap_analysis = analyzer_create();
+    // Analyse de l'espace mémoire inutilisé.
+    analyzer_t * memory_analysis = analyzer_create();
+    // Mesure de la durée d'une opération.
+    struct timespec before, after;
+    clockid_t clk_id = CLOCK_REALTIME;
+    // utilisé comme booléen pour savoir si un ajout a été effectué.
+    int insertion;
+
+    for(int i = BINARY_HEAP_LENGTH + 1; i > 1 ; i--){
+        fprintf(stderr, "Itération %d\n", i);
+
+        // Ajout d'un élément et mesure du temps pris par l'opération.
+        clock_gettime(clk_id, &before);
+        insertion = binary_heap_append(h, random_vector[i-1]);
+        clock_gettime(clk_id, &after);
+
+        if(!insertion){
+            fprintf(stderr, "Insertion non effectuée\n");
+
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+            fprintf(stderr, "!!!!! Aléatoire - TAS MAX INTERROMPU !!!!!\n");
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+
+            return EXIT_FAILURE;
+        }
+
+        // Enregistrement du temps pris par l'opération
+        analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
+        // Enregistrement des swaps de l'opération.
+        // S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
+        analyzer_append(swap_analysis, swap_number());
+        // Enregistrement de l'espace mémoire non-utilisé.
+        analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
+
+        fprintf(stderr, "A LA FIN DE L'ITER : ");
+        print_binary_heap(h);
+    }
+
+    // Affichage de quelques statistiques sur l'expérience.
+    fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
+    fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
+    fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
+    fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
+
+    // Sauvegarde les données de l'expérience.
+    save_values(time_analysis, "../../../../plots/dynamic_binary_heap_time_c_random_tas_max.plot");
+    save_values(swap_analysis, "../../../../plots/dynamic_binary_heap_swap_c_random_tas_max.plot");
+    save_values(memory_analysis, "../../../../plots/dynamic_binary_heap_memory_c_random_tas_max.plot");
+
+    // Nettoyage de la mémoire avant la sortie du programme
+    binary_heap_destroy(h);
+    analyzer_destroy(time_analysis);
+    analyzer_destroy(swap_analysis);
+    analyzer_destroy(memory_analysis);
+
+    fprintf(stderr, "************************************\n");
+    fprintf(stderr, "***** Aléatoire - TAS MAX FINI *****\n");
+    fprintf(stderr, "************************************\n");
+
+
+
+    /* TAS BINAIRE MIN */
+    // Tas Binaire de taille fixe
+    h = binary_heap_create(BINARY_HEAP_MIN);
+    // Analyse du temps pris par les opérations.
+    time_analysis = analyzer_create();
+    // Analyse des swap faits par les opérations.
+    swap_analysis = analyzer_create();
+    // Analyse de l'espace mémoire inutilisé.
+    memory_analysis = analyzer_create();
+    // Mesure de la durée d'une opération.
+    clk_id = CLOCK_REALTIME;
+    // utilisé comme booléen pour savoir si un ajout a été effectué.
+    insertion = FALSE;
+
+    for(int i = 1; i < BINARY_HEAP_LENGTH + 1 ; i++){
+        fprintf(stderr, "Itération %d\n", i);
+
+        // Ajout d'un élément et mesure du temps pris par l'opération.
+        clock_gettime(clk_id, &before);
+        insertion = binary_heap_append(h, random_vector[i-1]);
+        clock_gettime(clk_id, &after);
+
+        if(!insertion){
+            fprintf(stderr, "Insertion non effectuée\n");
+
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+            fprintf(stderr, "!!!!! Aléatoire - TAS MIN INTERROMPU !!!!!\n");
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+
+            return EXIT_FAILURE;
+        }
+
+        // Enregistrement du temps pris par l'opération
+        analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
+        // Enregistrement des swaps de l'opération.
+        // S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
+        analyzer_append(swap_analysis, swap_number());
+        // Enregistrement de l'espace mémoire non-utilisé.
+        analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
+
+        fprintf(stderr, "A LA FIN DE L'ITER : ");
+        print_binary_heap(h);
+    }
+
+    // Affichage de quelques statistiques sur l'expérience.
+    fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
+    fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
+    fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
+    fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
+
+    // Sauvegarde les données de l'expérience.
+    save_values(time_analysis, "../../../../plots/dynamic_binary_heap_time_c_random_tas_min.plot");
+    save_values(swap_analysis, "../../../../plots/dynamic_binary_heap_swap_c_random_tas_min.plot");
+    save_values(memory_analysis, "../../../../plots/dynamic_binary_heap_memory_c_random_tas_min.plot");
+
+    // Nettoyage de la mémoire avant la sortie du programme
+    binary_heap_destroy(h);
+    analyzer_destroy(time_analysis);
+    analyzer_destroy(swap_analysis);
+    analyzer_destroy(memory_analysis);
+    free(random_vector);
+
+    fprintf(stderr, "************************************\n");
+    fprintf(stderr, "***** Aléatoire - TAS MIN FINI *****\n");
+    fprintf(stderr, "************************************\n");
+
+
+    return EXIT_SUCCESS;
+}

C/TAS_DYNAMIQUE/1-Ajout/Croissant/Makefile

+CC= gcc
+CXXFLAGS= -Wall -ansi --pedantic -O3
+
+CPP_O_FILE = ../../__src/dynamic_binary_heap.o ../../__src/analyzer.o main_dynamique_ajout_croissant.o
+LIB = -lm
+
+
+all: $(CPP_O_FILE)
+	$(CC) $(CXXFLAGS) -o main_dynamique_ajout_croissant $(CPP_O_FILE) $(LIB)
+
+clean:
+	rm -rf ../../__src/*.o
+	rm -rf *.o
+	rm -rf *~
+	rm -rf main_dynamique_ajout_croissant

C/TAS_DYNAMIQUE/1-Ajout/Croissant/main_dynamique_ajout_croissant.c

+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include "../../__src/analyzer.h"
+#include "../../__src/dynamic_binary_heap.h"
+
+
+int main(int argc, char ** argv){
+
+    /* TAS BINAIRE MAX */
+    // Tas Binaire de taille fixe
+    binary_heap_t * h = binary_heap_create(BINARY_HEAP_MAX);
+    // Analyse du temps pris par les opérations.
+    analyzer_t * time_analysis = analyzer_create();
+    // Analyse des swap faits par les opérations.
+    analyzer_t * swap_analysis = analyzer_create();
+    // Analyse de l'espace mémoire inutilisé.
+    analyzer_t * memory_analysis = analyzer_create();
+    // Mesure de la durée d'une opération.
+    struct timespec before, after;
+    clockid_t clk_id = CLOCK_REALTIME;
+    // utilisé comme booléen pour savoir si un ajout a été effectué.
+    int insertion;
+
+    for(int i = 1; i < BINARY_HEAP_LENGTH + 1 ; i++){
+        fprintf(stderr, "Itération %d\n", i);
+
+        // Ajout d'un élément et mesure du temps pris par l'opération.
+        clock_gettime(clk_id, &before);
+        insertion = binary_heap_append(h, i);
+        clock_gettime(clk_id, &after);
+
+        if(!insertion){
+            fprintf(stderr, "Insertion non effectuée\n");
+
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+            fprintf(stderr, "!!!!! Croissant - TAS MAX INTERROMPU !!!!!\n");
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+
+            return EXIT_FAILURE;
+        }
+
+        // Enregistrement du temps pris par l'opération
+        analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
+        // Enregistrement des swaps de l'opération.
+        // S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
+        analyzer_append(swap_analysis, swap_number());
+        // Enregistrement de l'espace mémoire non-utilisé.
+        analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
+
+        fprintf(stderr, "A LA FIN DE L'ITER : ");
+        print_binary_heap(h);
+    }
+
+    // Affichage de quelques statistiques sur l'expérience.
+    fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
+    fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
+    fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
+    fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
+
+    // Sauvegarde les données de l'expérience.
+    save_values(time_analysis, "../../../../plots/dynamic_binary_heap_time_c_increasing_tas_max.plot");
+    save_values(swap_analysis, "../../../../plots/dynamic_binary_heap_swap_c_increasing_tas_max.plot");
+    save_values(memory_analysis, "../../../../plots/dynamic_binary_heap_memory_c_increasing_tas_max.plot");
+
+    // Nettoyage de la mémoire avant la sortie du programme
+    binary_heap_destroy(h);
+    analyzer_destroy(time_analysis);
+    analyzer_destroy(swap_analysis);
+    analyzer_destroy(memory_analysis);
+    fprintf(stderr, "************************************\n");
+    fprintf(stderr, "***** Croissant - TAS MAX FINI *****\n");
+    fprintf(stderr, "************************************\n");
+
+
+
+    /* TAS BINAIRE MIN */
+    // Tas Binaire de taille fixe
+    h = binary_heap_create(BINARY_HEAP_MIN);
+    // Analyse du temps pris par les opérations.
+    time_analysis = analyzer_create();
+    // Analyse des swap faits par les opérations.
+    swap_analysis = analyzer_create();
+    // Analyse de l'espace mémoire inutilisé.
+    memory_analysis = analyzer_create();
+    // Mesure de la durée d'une opération.
+    clk_id = CLOCK_REALTIME;
+    // utilisé comme booléen pour savoir si un ajout a été effectué.
+    insertion = FALSE;
+
+    for(int i = 1; i < BINARY_HEAP_LENGTH + 1 ; i++){
+        fprintf(stderr, "Itération %d\n", i);
+
+        // Ajout d'un élément et mesure du temps pris par l'opération.
+        clock_gettime(clk_id, &before);
+        insertion = binary_heap_append(h, i);
+        clock_gettime(clk_id, &after);
+
+        if(!insertion){
+            fprintf(stderr, "Insertion non effectuée\n");
+
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+            fprintf(stderr, "!!!!! Croissant - TAS MIN INTERROMPU !!!!!\n");
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+
+            return EXIT_FAILURE;
+        }
+
+        // Enregistrement du temps pris par l'opération
+        analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
+        // Enregistrement des swaps de l'opération.
+        // S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
+        analyzer_append(swap_analysis, swap_number());
+        // Enregistrement de l'espace mémoire non-utilisé.
+        analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
+
+        fprintf(stderr, "A LA FIN DE L'ITER : ");
+        print_binary_heap(h);
+    }
+
+    // Affichage de quelques statistiques sur l'expérience.
+    fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
+    fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
+    fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
+    fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
+
+    // Sauvegarde les données de l'expérience.
+    save_values(time_analysis, "../../../../plots/dynamic_binary_heap_time_c_increasing_tas_min.plot");
+    save_values(swap_analysis, "../../../../plots/dynamic_binary_heap_swap_c_increasing_tas_min.plot");
+    save_values(memory_analysis, "../../../../plots/dynamic_binary_heap_memory_c_increasing_tas_min.plot");
+
+    // Nettoyage de la mémoire avant la sortie du programme
+    binary_heap_destroy(h);
+    analyzer_destroy(time_analysis);
+    analyzer_destroy(swap_analysis);
+    analyzer_destroy(memory_analysis);
+
+    fprintf(stderr, "************************************\n");
+    fprintf(stderr, "***** Croissant - TAS MIN FINI *****\n");
+    fprintf(stderr, "************************************\n");
+
+
+    return EXIT_SUCCESS;
+}

C/TAS_DYNAMIQUE/1-Ajout/Decroissant/Makefile

+CC= gcc
+CXXFLAGS= -Wall -ansi --pedantic -O3
+
+CPP_O_FILE = ../../__src/dynamic_binary_heap.o ../../__src/analyzer.o main_dynamique_ajout_decroissant.o
+LIB = -lm
+
+
+all: $(CPP_O_FILE)
+	$(CC) $(CXXFLAGS) -o main_dynamique_ajout_decroissant $(CPP_O_FILE) $(LIB)
+
+clean:
+	rm -rf ../../__src/*.o
+	rm -rf *.o
+	rm -rf *~
+	rm -rf main_dynamique_ajout_decroissant

C/TAS_DYNAMIQUE/1-Ajout/Decroissant/main_dynamique_ajout_decroissant.c

+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include "../../__src/analyzer.h"
+#include "../../__src/dynamic_binary_heap.h"
+
+
+int main(int argc, char ** argv){
+
+    /* TAS BINAIRE MAX */
+    // Tas Binaire de taille fixe
+    binary_heap_t * h = binary_heap_create(BINARY_HEAP_MAX);
+    // Analyse du temps pris par les opérations.
+    analyzer_t * time_analysis = analyzer_create();
+    // Analyse des swap faits par les opérations.
+    analyzer_t * swap_analysis = analyzer_create();
+    // Analyse de l'espace mémoire inutilisé.
+    analyzer_t * memory_analysis = analyzer_create();
+    // Mesure de la durée d'une opération.
+    struct timespec before, after;
+    clockid_t clk_id = CLOCK_REALTIME;
+    // utilisé comme booléen pour savoir si un ajout a été effectué.
+    int insertion;
+
+    for(int i = BINARY_HEAP_LENGTH + 1; i > 1 ; i--){
+        fprintf(stderr, "Itération %d\n", i);
+
+        // Ajout d'un élément et mesure du temps pris par l'opération.
+        clock_gettime(clk_id, &before);
+        insertion = binary_heap_append(h, i);
+        clock_gettime(clk_id, &after);
+
+        if(!insertion){
+            fprintf(stderr, "Insertion non effectuée\n");
+
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+            fprintf(stderr, "!!!! Decroissant - TAS MAX INTERROMPU !!!!\n");
+            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+
+            return EXIT_FAILURE;
+        }
+
+        // Enregistrement du temps pris par l'opération
+        analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
+        // Enregistrement des swaps de l'opération.
+        // S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
+        analyzer_append(swap_analysis, swap_number());
+        // Enregistrement de l'espace mémoire non-utilisé.
+        analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
+
+        fprintf(stderr, "A LA FIN DE L'ITER : ");
+        print_binary_heap(h);
+    }
+
+    // Affichage de quelques statistiques sur l'expérience.
+    fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
+    fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
+    fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
+    fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
+
+    // Sauvegarde les données de l'expérience.
+    save_values(time_analysis, "../../../../plots/dynamic_binary_heap_time_c_decreasing_tas_max.plot");
+    save_values(swap_analysis, "../../../../plots/dynamic_binary_heap_swap_c_decreasing_tas_max.plot");
+    save_values(memory_analysis, "../../../../plots/dynamic_binary_heap_memory_c_decreasing_tas_max.plot");
+
+    // Nettoyage de la mémoire avant la sortie du programme
+    binary_heap_destroy(h);
+    analyzer_destroy(time_analysis);
+    analyzer_destroy(swap_analysis);
+    analyzer_destroy(memory_analysis);
+
+    fprintf(stderr, "************************************\n");
+    fprintf(stderr, "**** Decroissant - TAS MAX FINI ****\n");
+    fprintf(stderr, "************************************\n");
+
+
+
+    /* TAS BINAIRE MIN */
+    // Tas Binaire de taille fixe
+    h = binary_heap_create(BINARY_HEAP_MIN);
+    // Analyse du temps pris par les opérations.
+    time_analysis = analyzer_create();
+    // Analyse des swap faits par les opérations.
+    swap_analysis = analyzer_create();
+    // Analyse de l'espace mémoire inutilisé.
+    memory_analysis = analyzer_create();
+    // Mesure de la durée d'une opération.
+    clk_id = CLOCK_REALTIME;
+    // utilisé comme booléen pour savoir si un ajout a été effectué.