Commit d4044912 authored by BENGHEZALA_ROMAISSA's avatar BENGHEZALA_ROMAISSA
Browse files

exo1

parent 5d149387
Pipeline #4672 failed with stage
in 6 seconds
#include<stdio.h>
#include <time.h>
#include<stdlib.h>
#include "arraylist.h"
#include "analyzer.h"
#include "tasbinaire.h"
int main(int argc, char ** argv){
int i;
// Tableau dynamique.
tas_binaire_t * a = cree_tas_binaire(10000);
// Analyse du temps pris par les opérations.
analyzer_t * time_analysis = analyzer_create();
// Analyse du nombre de copies faites par les opérations.
analyzer_t * copy_analysis = analyzer_create();
// Analyse de l'espace mémoire inutilisé.
analyzer_t * memory_analysis = analyzer_create();
// Analyse du nombre d'echange effectuée.
analyzer_t * swap_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 une allocation a été effectuée.
char memory_allocation;
//Ajout des valeurs ALEATOIREMENT
float nombre_alea;
float prob = 0.5;
srand(time(NULL));
for(int i = 0; i < 10000 ; i++){
float p =(float) rand()/(float) RAND_MAX;
nombre_alea=rand()%10000;
if(p < prob){
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
memory_allocation = insertion_tas_binaire(a, nombre_alea);
clock_gettime(clk_id, &after);
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement du nombre de copies efféctuées par l'opération.
// S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
analyzer_append(copy_analysis, (memory_allocation)? i:1 );
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,tas_binaire_capacity(a)-tas_binaire_size(a));
// Enregistrement du nombre d'echange effectuée
analyzer_append(swap_analysis,tas_binaire_echange(a));
}else{
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
memory_allocation = tas_binaire_extraire_min(a);
clock_gettime(clk_id, &after);
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement du nombre de copies efféctuées par l'opération.
// S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
analyzer_append(copy_analysis, (memory_allocation)? i:1 );
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,tas_binaire_capacity(a)-tas_binaire_size(a));
// Enregistrement du nombre d'echange effectuée
analyzer_append(swap_analysis,tas_binaire_echange(a));
}
}
// 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_array_time_c_0.5.plot");
save_values(swap_analysis, "../plots/dynamic_array_swap_c_0.5.plot");
save_values(memory_analysis, "../plots/dynamic_array_memory_c_0.5.plot");
// Nettoyage de la mémoire avant la sortie du programme
tas_binaire_detruire(a);
analyzer_destroy(time_analysis);
analyzer_destroy(copy_analysis);
analyzer_destroy(memory_analysis);
analyzer_destroy(swap_analysis);
return EXIT_SUCCESS;
}
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "tasbinaire.h"
tas_binaire_t * cree_tas_binaire(int val){
tas_binaire_t* tas = (tas_binaire_t *) malloc( sizeof(tas_binaire_t) );
if(!tas)
return NULL;
tas->tab = (int *) malloc( sizeof(int) * val );
tas->taille = val;
tas->size = 0;
tas->echange = 0;
return tas;
}
int tas_binaire_pere(int clef) {
return (int) floor(clef/2);
}
void tas_binaire_echange_val(tas_binaire_t * t, int clef, int val) {
t->tab[clef] = val;
while (clef > 0 && t->tab[ tas_binaire_pere(clef)] > t->tab[clef]) {
int tmp = t->tab[ tas_binaire_pere(clef)];
t->tab[ tas_binaire_pere(clef)] = t->tab[clef];
t->tab[clef] = tmp;
t->echange ++;
clef = tas_binaire_pere(clef);
}
}
char insertion_tas_binaire(tas_binaire_t* t , int cle){
char memory_allocation = FALSE;
if (t!=NULL){
if(t->size < t->taille ){
tas_binaire_echange_val(t, t->size,cle);
memory_allocation = TRUE;
t->size++;
} else {
perror("tas binaire plein.");
}
}
return memory_allocation ;
}
void tas_binaire_detruire(tas_binaire_t* t){
if( t != NULL ){
if(t->tab != NULL ){
free( t->tab );
}
free(t);
}
}
size_t tas_binaire_capacity(tas_binaire_t * t){
return ( t!=NULL) ? t->taille : -1;
}
size_t tas_binaire_size(tas_binaire_t * t){
return ( t!=NULL) ? t->size : -1;
}
int tas_binaire_echange (tas_binaire_t * t){
return t->echange;
}
char tas_binaire_extraire_min (tas_binaire_t * t){
char memory_allocation = FALSE;
if (t!=NULL){
int i = 0;
int filsg = 2*i+1;
int filsd = 2*i+2;
int temp = 0;
t->echange = 0;
while ( i < t->size-1 ) {
if ( t->tab[filsg] > t->tab[filsd]){
temp = t->tab[i];
t->tab[i] = t->tab[filsd];
t->tab[filsd] = temp;
i = filsd;
}else {
temp = t->tab[i];
t->tab[i] = t->tab[filsg];
t->tab[filsg] = temp;
i = filsg;
}
filsg = 2*i+1;
filsd = 2*i+2;
t->echange++;
}
memory_allocation = TRUE;
}
return memory_allocation ;
}
#ifndef TAS_BINAIRE_H
#define TAS_BINAIRE_H
#define FALSE 0
#define TRUE 1
typedef struct tas_binaire_s{
//la taille du tableau
size_t taille;
//Nombre d'éléments stockés dans le tableau.
size_t size;
//Nombre d'echange effectuée
int echange;
// Pointeur vers la zone de mémoire où les entiers seront stockées.
int* tab;
}tas_binaire_t;
/**
Fonction de creation d'un tas binaire de taille val.
Complexité en temps/espace, pire et meilleur cas : O(1)
@param val est un entier qui représente la taille du tas binaire.
*/
tas_binaire_t * cree_tas_binaire(int val);
/**
Ajoute une valeur dans le tas binaire.
Complexité en temps/espace, pire cas : O(size)
Complexité en temps/espace, meilleur cas : O(1)
Complexité amortie : O(1)
@param t est le tas binaire auquel on souhaite ajouter une valeur.
@param cle est l'indice de la valeur que l'on souhaite ajouter.
@param val est la valeur que l'on souhaite ajouter.
*/
void tas_binaire_echange_val(tas_binaire_t * t, int clef, int val);
/**
Ajoute une valeur dans le tas binaire.
Complexité en temps/espace, pire cas : O(size)
Complexité en temps/espace, meilleur cas : O(1)
Complexité amortie : O(1)
@param t est le tas binaire auquel on souhaite ajouter une valeur.
@param cle est la valeur que l'on souhaite ajouter.
@returns VRAI si on a ajouté l'élément, FAUX sinon
*/
char insertion_tas_binaire(tas_binaire_t* t , int cle);
/**
Fonction de libération de la mémoire occupée par un tas binaire.
Complexité en temps/espace, pire et meilleur cas : O(1)
@param t est un pointeur vers l'espace mémoire que la fonction va libérer.
*/
void tas_binaire_detruire(tas_binaire_t* t);
/**
Renvoie la capacité de stockage du tableau (tas binaire).
Complexité en temps/espace, pire cas : O(1)
@param t est un pointeur vers un tableau (tas binaire).
@returns la capacité de stockage du tableau (tas binaire).
*/
size_t tas_binaire_capacity(tas_binaire_t * t);
/**
Renvoie le nombre d'éléments stockés dans le tableau (tas binaire).
Complexité en temps/espace, pire cas : O(1)
@param t est un pointeur vers un tableau (tas binaire).
@returns le nombre d'éléments stockés dans le tableau (tas binaire).
*/
size_t tas_binaire_size(tas_binaire_t * t);
/**
Renvoie le nombre d'echange effectuée dans l'insertion en tas binaire
Complexité en temps pire cas : O(taille)
Complexité en espace pire cas : O(1)
@param t est un pointeur vers un tableau (tas binaire).
@return le nombre d'echange effectuée
*/
int tas_binaire_echange (tas_binaire_t * t);
/**
Extraire le min de tas
Complexité en temps pire cas : O(taille)
Complexité en espace pire cas : O(1)
@param t est un pointeur vers un tableau (tas binaire).
@returns VRAI si on a ajouté l'élément, FAUX sinon
*/
char tas_binaire_extraire_min (tas_binaire_t * t);
#endif
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment