diff --git a/header/readfile.h b/header/readfile.h index 0c1d30a..8e19cd8 100644 --- a/header/readfile.h +++ b/header/readfile.h @@ -4,4 +4,7 @@ #include int getNbLines(FILE * readFile); -char * getLines(FILE * readFile,int nbLines); \ No newline at end of file +int getFileSize(FILE * readFile); +void getStringFromFile(FILE * readFile,int nbLines,char * returnString,int * size); +char * getLine(char * string,int line); +void string2Coureur(char * string,int nbLines); \ No newline at end of file diff --git a/src/liste.c b/src/liste.c index 89f16ea..a06399a 100644 --- a/src/liste.c +++ b/src/liste.c @@ -3,12 +3,23 @@ int main(void) { + int size; FILE * f=fopen ("fichier_coureurs.txt","r"); - //printf("Number of lines : %d\n",getNbLines(f)); - getLines(f,getNbLines(f)); + char * fileString = (char *)(malloc(getFileSize(f)*sizeof(char))); + int fileLines = getNbLines(f); + getStringFromFile(f,fileLines,fileString,&size); + int stepsNb = atoi(getLine(fileString,1)); + int teamsNb = atoi(getLine(fileString,2)); + printf("Nombre d'etapes : %d\t Nombre d'equipes :%d\n",stepsNb,teamsNb); + string2Coureur(fileString,fileLines); return 0; } +/** + * @brief initialise un element en memoire qui encapsule une strucure de coureur au champs vide + * + * @return returnElement retourne un element vierge + */ struct element * initElement(void) { struct element * returnElement = (struct element *)malloc(sizeof(struct element)); @@ -17,6 +28,12 @@ struct element * initElement(void) return returnElement; } +/** + * @brief initialise chaque element de la liste a partir de initElement + * + * + * @return l + */ liste initListe(void) { liste l; @@ -69,24 +86,42 @@ void printlist(liste l) printf("NULL \n"); } - - -void allerDebut(liste * l)// car demandee dans le TP zero reference +/** + * @brief Mettre le poiteur courant d'une liste sur le premiere element + * + * @param l liste ou l'on modifie le poiteur courant + */ +void allerDebut(liste * l) { l->courant = l->debut; } -void allerFin(liste * l)// car demandee dans le TP zero reference +/** + * @brief Mettre le poiteur courant d'une liste sur le derniee element + * + * @param l liste ou l'on modifie le poiteur courant + */ +void allerFin(liste * l) { l->courant = l->fin; } -void avancer(liste * l) // car demandee dans le TP zero reference +/** + * @brief Mettre le poiteur courant sur l'element suivant + * + * @param l liste ou l'on modifie le poiteur courant + */ +void avancer(liste * l) { l->courant = l->courant->suiv; } -coureur * coureurCourant(liste * l)// car demandee dans le TP zero reference +/** + * @brief Retourne le coureur encapsulee dans l'element pointer par le pointeur courant + * + * @param l liste ou l'on modifie le poiteur courant + */ +coureur * coureurCourant(liste * l) { return l->courant->coureurActuel; } @@ -97,95 +132,160 @@ coureur * coureurCourant(liste * l)// car demandee dans le TP zero reference * fonctionnement : -declaration d'un poiteur eParcours egale l'adresse du premiere element (variable temporaire) -declaration d'un poiteur(ePrevious) qui stockera temporairement l'adresse des elements pendant la reconstruction du chainage - - - * @param listeActuel - * @param coureurSuppr + -si l'element a supprimer est le premiere element de la liste : + -le poiteur courant pointe sur l'element suivant + -le poiteur pointant sur le premiere element poite sur le deuxieme + -si l'element a suppr n'est pas le deuxieme : + -ePrevious egale l'adresse du premiere element + -eParcours egale l'adresse du deuxieme element + -tant que l'element poitee par eParcours ne contient pas le courreur a supprimer faire : + -ePrevious pointe sur l'element suivant + -eParcours pointe sur l'element suivant + -l'element avant celui a suprimer pointe sur l'element sur le qu'elle poite l'element a supprimer + -supression de l'element + + * @param listeActuel Liste ou l'on suppr un element + * @param coureurSuppr le coureur qui doit etre dans l'element pour le supprimer */ void effacerCoureur(liste * listeActuel,coureur * coureurSuppr) { struct element *eParcours =listeActuel->debut; struct element * ePrevious; - if(eParcours->coureurActuel == coureurSuppr) //si l'element a supprimer est le premiere element de la liste : + if(eParcours->coureurActuel == coureurSuppr) { - listeActuel->courant=eParcours->suiv; //le poiteur courant pointe sur l'element suivant - listeActuel->debut=eParcours->suiv; //le poiteur pointant sur le premiere element poite sur le deuxieme + listeActuel->courant=eParcours->suiv; + listeActuel->debut=eParcours->suiv; } - else{ //si l'element a suppr n'est pas le deuxieme - ePrevious=eParcours; //ePrevious egale l'adresse du premiere element - eParcours=eParcours->suiv; //eParcours egale l'adresse du deuxieme element - while(eParcours->coureurActuel != coureurSuppr){ //tant que l'element poitee par eParcours ne contient pas le courreur a supprimer faire : - ePrevious=ePrevious->suiv; //ePrevious pointe sur l'element suivant - eParcours=eParcours->suiv; //eParcours pointe sur l'element suivant + else{ + ePrevious=eParcours; + eParcours=eParcours->suiv; + while(eParcours->coureurActuel != coureurSuppr){ + ePrevious=ePrevious->suiv; + eParcours=eParcours->suiv; } - ePrevious->suiv=eParcours->suiv; //l'element avant celui a suprimer pointe sur l'element sur le qu'elle poite l'element a supprimer - free(eParcours); //supression de l'element + ePrevious->suiv=eParcours->suiv; + free(eParcours); } } +/** + * @brief Renvoie le nombre d'elements d'une liste + fonctionnement : + -initilisation a 0 d'un compteur (int) + -decleration d'un poiteur elementActuel initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage + -tant que elementActuel n'est pas egale a l'adresse du derniere element faire + -increment compteur + -elementActuel pointe sur l'element suivant + -retourne le compteur + + * + * @param l l la liste dont on ve connaitre la taille + * @return int le nombre d'element (on compte a partir de 0) + */ int tailleListe(liste l) { - int returnValue=0; //initilisation a 0 d'un compteur (int) - struct element * elementActuel = l.debut; //decleration d'un poiteur elementActuel initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage - while(elementActuel->suiv != l.fin->suiv) //tant que elementActuel n'est pas egale a l'adresse du derniere element faire : + int returnValue=0; + struct element * elementActuel = l.debut; + while(elementActuel->suiv != l.fin->suiv) { - returnValue++; //increment compteur - elementActuel=elementActuel->suiv; //elementActuel pointe sur l'element suivant + returnValue++; + elementActuel=elementActuel->suiv; }; - return returnValue; //retourne le compteur + return returnValue; } +/** + * @brief retourne le courreur contenue dans l'element nb d'une liste (on considere un element 0) + * fonctionnement : + -init elementCourant a l'adresse du premiere element de la liste + -pour i allant de 0 a nb-1 + -a la fin de la boucle elementcourant pointe sur l'element nb (on considere un element 0) + -renvoie le coureur encapsulee dans l'element nb + * @param l la liste ou doit se trouver l'element encapsulant le coureur + * @param nb le numero d'element rechercher + * @return coureur* + */ coureur * getCoureur(liste l,int nb) { - struct element * elementCourant = l.debut; //init elementCourant a l'adresse du premiere element de la liste + struct element * elementCourant = l.debut; for(int i=0;isuiv; //a la fin de la boucle elementcourant pointe sur l'element nb (on considere un element 0) + elementCourant=elementCourant->suiv; } - return elementCourant->coureurActuel; //renvoie le coureur encapsulee dans l'element nb + return elementCourant->coureurActuel; } - +/** + * @brief inverse l'element nb et nb+1 dans une liste (on considere un element 0) + * fonctionnement : + -decleration d'un poiteur elementCourant initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage + -declaration et allocation en memoire(a l'adresse *elemeentPrecedent) d'une taille de structure element de type element + -pour i allant de 0 a nb-1 faire : + -en fin de boucle elementCourant poite sur l'element nb et elementPrecendent nb-1 + + -declaration de elementsuivant qui poite sur l'element nb+1 + -elementCourant pointe sur nb+1 + -elementSuivant pointe sur nb + -si l'element a intervertir est le premier : + -le poiteur courant pointe sur l'ancien deuxieme element + -le poiteur debut pointe sur l'ancien deuxieme + -si l'element a intervertir diff du premier : + -element nb-1 pointe sur element nb + -le poiteur courant pointe sur le premier element + * @param l liste ou l'on inverse les elements + * @param nb le numero d'element inverser avec nb+1 + */ void invertCoureur(liste * l,int nb) { - struct element * elementDebut = l->debut; //decleration d'un poiteur elementCourant initialisee au poiteur debut present dans liste qui pointe sur le premier element du chainage - struct element * elementPrecedent = (struct element *)(malloc(sizeof(struct element)));//declaration et allocation en memoire(a l'adresse *elemeentPrecedent) d'une taille de structure element de type element - for(int i=0;idebut; + struct element * elementPrecedent = (struct element *)(malloc(sizeof(struct element))); + for(int i=0;isuiv; } - struct element * elementSuivant = elementDebut->suiv; //declaration de elementsuivant qui poite sur l'element nb+1 - elementDebut->suiv=elementSuivant->suiv; //elementCourant pointe sur nb+1 - elementSuivant->suiv=elementDebut; //elementSuivant pointe sur nb - if(nb==0) //si l'element a intervertir est le premier : + struct element * elementSuivant = elementDebut->suiv; + elementDebut->suiv=elementSuivant->suiv; + elementSuivant->suiv=elementDebut; + if(nb==0) { - l->courant=elementSuivant; //le poiteur courant pointe sur l'ancien deuxieme element - l->debut=l->courant; //le poiteur debut pointe sur l'ancien deuxieme + l->courant=elementSuivant; + l->debut=l->courant; } - else{ //si l'element a intervertir diff du premier : - elementPrecedent->suiv = elementSuivant; //element nb-1 pointe sur element nb - l->courant=l->debut; //le poiteur courant pointe sur le premier element + else{ + elementPrecedent->suiv = elementSuivant; + l->courant=l->debut; } } - void triListe(liste * l,int taille) +/** + * @brief trie bulle des element d'une liste a partir du temps contenue dans la structure encapsule dans l'element + * fonctionnement : + -pour i allant du nombre d'element dans la liste a 2 step -1 + -pour j allant de 0 a i-1 step 1 + -si leCourreur taille -i a un temps < au coureur taille-i+1 + -inverser les courreurs j et j+1 + + * @param l liste a trier + * @param taille represente la taille de la liste + */ +void triListe(liste * l,int taille) +{ + bool tabOrdered = true; + for(int i=taille-1;i>1;i--) { - bool tabOrdered = true; - for(int i=taille-1;i>1;i--) //pour i allant du nombre d'element dans la liste a 2 step -1 + for(int j=0;j<=i-1;j++) { - for(int j=0;j<=i-1;j++) //pour j allant de 0 a i-1 step 1 + if(getCoureur(*l,j+1)->temps < getCoureur(*l,j)->temps) { - if(getCoureur(*l,j+1)->temps < getCoureur(*l,j)->temps)//si leCourreur taille -i a un temps < au coureur taille-i+1 - { - invertCoureur(l,j); //inverser les courreurs - tabOrdered = false; - } - //printlist(*l); - } - if(tabOrdered) - { - return; + invertCoureur(l,j); + tabOrdered = false; } + printlist(*l); + } + if(tabOrdered) + { + return; } } - +} \ No newline at end of file diff --git a/src/readfile.c b/src/readfile.c index d5d2cdf..49ac104 100644 --- a/src/readfile.c +++ b/src/readfile.c @@ -1,4 +1,5 @@ #include "../header/readfile.h" +#define MAXLINE 50 int getNbLines(FILE * readFile) { @@ -13,14 +14,74 @@ int getNbLines(FILE * readFile) return count+1; } -char * getLines(FILE * readFile,int nbLines) +void getStringFromFile(FILE * readFile,int nbLines,char * returnString,int * size) { int i; - char str[100]; + char temp[MAXLINE]; + *size=0; + strcpy(returnString,""); fseek(readFile,0,0); for(i=0;i5) + { + j=0; + printf("\n"); + } } } \ No newline at end of file