From 852d60c5a46043377ad6a49a89d40582299b8c81 Mon Sep 17 00:00:00 2001 From: yoboujon Date: Thu, 24 Nov 2022 13:45:31 +0100 Subject: [PATCH] Ajout du code de base --- coureur.c | 37 +++++++++++ coureur.h | 17 +++++ liste.c | 184 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ liste.h | 27 ++++++++ 4 files changed, 265 insertions(+) create mode 100644 coureur.c create mode 100644 coureur.h create mode 100644 liste.c create mode 100644 liste.h diff --git a/coureur.c b/coureur.c new file mode 100644 index 0000000..40fc60e --- /dev/null +++ b/coureur.c @@ -0,0 +1,37 @@ +#include "coureur.h" //inclure le fichier "coureur.h" qui contien les libs, structure et prototypes + +// Creation d'un coureur en memoire avec recupération de son adrresse avec le parametrage de c'est different champs +coureur * creerCoureur(char nom[],char prenom[],int dossard, char equipe[],int temps) +{ + coureur * leCoureur = malloc(sizeof(coureur)); //initilisation taille memoire taille de structure + + leCoureur->nom = malloc(sizeof(char)*strlen(nom)); //initilisation taille memoire 4oct*tailleChaine + strcpy(leCoureur->nom,nom); //copy de nom(para) dans le champs nom de la structure leCoureur + leCoureur->prenom = malloc(sizeof(char)*strlen(prenom));//initilisation taille memoire 4oct*tailleChaine + strcpy(leCoureur->prenom,prenom); //copy de prenom(para) dans le champs prenom de la structure leCoureur + leCoureur->equipe = malloc(sizeof(char)*strlen(equipe));//initilisation taille memoire 4oct*tailleChaine + strcpy(leCoureur->equipe,equipe); //copy de equipe(para) dans le champs equipe de la structure leCoureur + + leCoureur->temps=temps; //ecriture temps(para) dans le champs temps de la structure leCoureur + leCoureur->dossard=dossard; //ecriture dossard un int dans le champs dossard de la structure leCoureur + + return leCoureur; //retour addresse de la structure crée "leCoureur" +} + + +//Modifier le temps d'un coureur a partir de son adresse et d'une valeur de cumule +void ajouterTemps(int leTemps,coureur * leCoureur) +{ + leCoureur->temps+=leTemps; //Cumul du champ temps appartenant a la structure leCoureur avec leTemp(para) qui est un int +} + +//Afficher le temps d'un coureur stocker en seconde sous forme d'heures, de minutes et de secondes ( a partir de l'adresse de sa structure de définition) +void afficherCoureur(coureur * leCoureur) +{ + int heure,minute,seconde; //initilisation de 3 variable tampon + heure = (int)(leCoureur->temps)/3600; //calcul d'heures qui renvoie uniquement la partie entier + minute = (int)((leCoureur->temps-heure*3600)/60); //calcul de minutes qui renvoie uniquement la partie entier avec la prise en compte des heures soustraite en minutes + seconde = leCoureur->temps-(heure*3600+minute*60); //calcul de seconde qui renvoie uniquement la partie entier avec la prise en compte des heures soustraite en secondes et des minutes en secondes + + printf("Nom : %s\tPrenom : %s\tDossard : %d\tEquipe : %s\tTemps : %d:%d:%d\n",leCoureur->nom,leCoureur->prenom,leCoureur->dossard,leCoureur->equipe,heure,minute,seconde); +} \ No newline at end of file diff --git a/coureur.h b/coureur.h new file mode 100644 index 0000000..dc40e80 --- /dev/null +++ b/coureur.h @@ -0,0 +1,17 @@ +#include //lib de base +#include //lib de base +#include //lib de base +#include //lib de base + +typedef struct{ //definition de la structure coureur + char * nom; + char * prenom; + int dossard; + char * equipe; + int temps; +} coureur; + +//Prototype +coureur * creerCoureur(char nom[],char prenom[],int dossard, char equipe[],int temps);// Creation d'un coureur en memoire avec recupération de son adrresse avec le parametrage de c'est different champs +void ajouterTemps(int leTemps,coureur * leCoureur); //Modifier le temps d'un coureur a partir de son adresse et d'une valeur de cumule +void afficherCoureur(coureur * leCoureur); //Afficher le temps d'un coureur stocker en seconde sous forme d'heures, de minutes et de secondes ( a partir de l'adresse de sa structure de définition) \ No newline at end of file diff --git a/liste.c b/liste.c new file mode 100644 index 0000000..7a1be4b --- /dev/null +++ b/liste.c @@ -0,0 +1,184 @@ +#include "liste.h" + +int main(void) +{ + coureur * c1 = creerCoureur("Paris","Simon",15,"TRAUFORE",50000); //creation coureur + coureur * c2 = creerCoureur("Bougeont","Yoann",65,"MEILLEUR",99994); //creation coureur + coureur * c3 = creerCoureur("Barakai","Obama",120,"AMERICA",372); //creation coureur + coureur * c4 = creerCoureur("Boujon","Yohan",56,"MAISYEUR",49999); //creation coureur + coureur * c5 = creerCoureur("Runner","Tedi",1,"JUDOOOKA",120); //creation coureur + coureur * c6 = creerCoureur("Fatigue","Jean",69,"DODODODO",11554751); //creation coureur + printf(" -- COUREUR -- \n"); + afficherCoureur(c1); //Afficher les champs de la structure coureur c1 + ajouterTemps(50,c1); //Ajoutee 50 seconde dans le champ temp de c1 + afficherCoureur(c1); //Afficher les champs de la structure coureur c1 + liste l1 = initListe(); //declaration de la liste l1 et initialisation + ajoutListe(&l1,c1); //ajout d'un element contenat c1 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global) + ajoutListe(&l1,c2); //ajout d'un element contenat c2 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global) + ajoutListe(&l1,c3); //ajout d'un element contenat c3 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global) + ajoutListe(&l1,c4); //ajout d'un element contenat c4 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global) + ajoutListe(&l1,c5); //ajout d'un element contenat c5 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global) + ajoutListe(&l1,c6); //ajout d'un element contenat c6 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global) + printf(" -- AJOUT LISTE, taille =%d -- \n",tailleListe(l1)); + printlist(l1); + effacerCoureur(&l1,c2); + printf(" -- SUPR LISTE, taille =%d -- \n",tailleListe(l1)); + printlist(l1); + printf(" -- INTERVERTI COUREUR 1 ET 2 DE LA LISTE -- \n"); + invertCoureur(&l1,1); + printlist(l1); + printf(" -- INTERVERTI COUREUR 0 ET 1 DE LA LISTE -- \n"); + invertCoureur(&l1,0); + printlist(l1); + printf(" -- COUREUR 2 DE LA LISTE -- \n"); + afficherCoureur(getCoureur(l1,2)); + printf(" -- TRI LISTE -- \n"); + triListe(&l1,tailleListe(l1)); + printlist(l1); + return 0; +} + +struct element * initElement(void) +{ + struct element * returnElement = (struct element *)malloc(sizeof(struct element)); + returnElement->coureurActuel = creerCoureur("","",0,"",0); + returnElement->suiv = NULL; + return returnElement; +} + +liste initListe(void) +{ + liste l; + l.debut=initElement(); + l.fin=initElement(); + l.courant=initElement(); + return l; +} + +void ajoutListe(liste * listeActuel,coureur * leCoureur) //avec "leCoureur" le coureur a rajouter +{ + struct element * elementActuel = (struct element *)malloc(sizeof(struct element)); //declaration et allocation en memoire(a l'adresse *elementActuel) d'une taille de structure element de type element (Creation element vierge de taille element) + elementActuel->coureurActuel=leCoureur; //dans la variable elementActuel le champ coureurActuel devient leCourreur (l'element vierge est remplie avec le coureur a rajoute) + elementActuel->suiv=listeActuel->courant; //dans la variable elementActuel le champ suiv devient le poiteur courant (l'element vierge poite sur le debut le poiteur courant (le premier element)chainage) + listeActuel->debut=elementActuel; //le poiteur de premiere element contenue dans liste pointe sur le nouvelle element + listeActuel->courant=elementActuel; //le poiteur courant contenue dans la liste pointe sur le nouvelle element +} + +void printlist(liste l) +{ + struct element * eCourant = l.courant; + struct element * eFin = l.fin; + while(eCourant->suiv != eFin->suiv) + { + afficherCoureur(eCourant->coureurActuel); + eCourant=eCourant->suiv; + } + printf("NULL \n"); +} + +void allerDebut(liste * l) +{ + l->courant = l->debut; +} + +void allerFin(liste * l) +{ + l->courant = l->fin; +} + +void avancer(liste * l) +{ + l->courant = l->courant->suiv; +} + +coureur * coureurCourant(liste * l)//------------------------------------------------------------------------Artefacte +{ + return l->courant->coureurActuel; +} + +void effacerCoureur(liste * listeActuel,coureur * coureurSuppr) +{ + struct element * eParcours = listeActuel->courant; + struct element * ePrevious; + if(eParcours->coureurActuel == coureurSuppr) + { + listeActuel->courant=eParcours->suiv; + listeActuel->debut=eParcours->suiv; + } + else{ + ePrevious=eParcours; + eParcours=eParcours->suiv; + while(eParcours->coureurActuel != coureurSuppr){ + ePrevious=ePrevious->suiv; + eParcours=eParcours->suiv; + } + ePrevious->suiv=eParcours->suiv; + free(eParcours); + } +} + +int tailleListe(liste l) +{ + int returnValue=0; + struct element * elementActuel = l.courant; + while(elementActuel->suiv != l.fin->suiv) + { + returnValue++; + elementActuel=elementActuel->suiv; + }; + return returnValue; +} + +coureur * getCoureur(liste l,int nb) +{ + struct element * elementCourant = l.courant; + for(int i=0;isuiv; + } + return elementCourant->coureurActuel; +} + +void invertCoureur(liste * l,int nb) +{ + struct element * elementCourant = l->courant; + struct element * elementPrecedent = (struct element *)(malloc(sizeof(struct element))); + for(int i=0;isuiv; + } + struct element * elementSuivant = elementCourant->suiv; + elementCourant->suiv=elementSuivant->suiv; + elementSuivant->suiv=elementCourant; + if(nb==0) + { + l->courant=elementSuivant; + l->debut=l->courant; + } + else{ + elementPrecedent->suiv = elementSuivant; + l->courant=l->debut; + } +} + +void triListe(liste * l,int taille) +{ + bool tabOrdered = true; + for(int i=taille-1;i>1;i--) + { + for(int j=0;j<=i-1;j++) + { + if(getCoureur(*l,j+1)->temps < getCoureur(*l,j)->temps) + { + invertCoureur(l,j); + tabOrdered = false; + } + printlist(*l); + } + if(tabOrdered) + { + return; + } + } +} \ No newline at end of file diff --git a/liste.h b/liste.h new file mode 100644 index 0000000..55ba5dc --- /dev/null +++ b/liste.h @@ -0,0 +1,27 @@ +#include "coureur.h" //inclure le fichier "coureur.h" qui contien les libs et la structure coureur + +struct element{ //definition de la structure qui element qui sera encaspule/chaine + coureur * coureurActuel; //"contient" l'adresse d'une structure coureur + struct element * suiv; //"contient" l'adresse d'une autre strucutre element(chainage) +}; + +typedef struct{ //definition de la structure liste qui "contient" l'encaspsulation + struct element * debut; //"contient" un element en debut *voir init dans liste.c + struct element * courant; //"contient"element actuel *voir init dans liste.c + struct element * fin; //"contient"element en fin de la liste (NULL) *voir init dans liste.c +} liste; + +//Prototype de fonction +struct element * initElement(void); //initialise un element en memoir qui encapsule une strucure de coureurau champs vide +liste initListe(void); //initialise chaque element de la liste a partir de initElement +void ajoutListe(liste * listeActuel,coureur * leCoureur); //ajoute un element contenant un courreur dans le chainage d'une liste +void printlist(liste l); //afficher le coureur dans chaque element d'une liste +void allerDebut(liste * l); //mettre le poiteur courant sur l'element premier d'une liste +void allerFin(liste * l); //mettre le poiteur courant sur l'element de fin d'une liste +void avancer(liste * l); //mettre le poiteur courant sur l'element suivant de la liste dans la qu'elle qu'il pointe +coureur * coureurCourant(liste * l); //rien a foutre ici +void effacerCoureur(liste * listeActuel,coureur * coureurSuppr);//enleve un element d'une liste a partir de l'adresse d'un courreur, sans briser le chainage +int tailleListe(liste l); //retourne le nombre d'elements chaine d'une liste +coureur * getCoureur(liste l,int nb); // +void invertCoureur(liste * l,int nb); // +void triListe(liste * l,int taille); //trie bulle des element d'une liste a partir du temps contenue dans la structure encapsule dans l'element \ No newline at end of file