Commit 9e81ff00 authored by MARRAKCHI Ghassen's avatar MARRAKCHI Ghassen
Browse files

Exercices 1, 2 & 3

parent ad39936d
{
"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
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
#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;
}
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
#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;
}
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
#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;
}
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
#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é.