Ajout de toutes les fonctions pour la liste des candidats admis

Commun.c

@@ -857,10 +857,6 @@ void enregistrement(VilleIUT *tiut[],int tLog) /* Permet l'enregistrement du tab
 /****************************************** Et de sauvegarde*************************************************/
 /************************************************************************************************************/
 
-/************************************** Fonctions de Chargement ********************************************/
-/****************************************** Et de sauvegarde*************************************************/
-/************************************************************************************************************/
-
 Candidat ** chargementCandidats(int *tMax) /* Permet de charger le contenu du fichier Candidats.don dans un tableau de pointeur vers */
 {                                          /* des structures Candidats qui contiennent un tableau de pointeurs vers des structures choix*/
     FILE *flot;                            /* La fonction renvoie ensuite le tableau de Candidats si tout se passe bien */
@@ -1261,73 +1257,73 @@ int miseAJourChoixCand(Choix *tChoix[], int nombreChoix) /* Fontcion permettant
 }
 
 
-/*void miseAJourChoixResp(Choix *tChoix[], int pos)  Fontcion permettant de mettre à jour la décision d'un responsable d'admission concernant un candidat 
-{
-    int saisie;
-    system("clear");
-    if(tChoix[pos]->decisionCand == 0)  Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire 
-    {                                  
-        printf("Votre décision est actuellement en attente\n\n");
-        printf("|---------------------------------------|\n");
-        printf("|       Que souhaitez-vous faire ?      |\n");
-        printf("|---------------------------------------|\n");
-        printf("| 1 Accepter la demande d'admission     |\n");
-        printf("| 2 Mettre sur liste d'attente          |\n");
-        printf("| 3 Refuser la demande d'admission      |\n");
-        printf("| 4 Ne rien changer                     |\n");
-        printf("|---------------------------------------|\n");
-        printf("Saisie : ");
-        scanf("%d%*c", &saisie);
-        printf("\n");
-        if(saisie == 1)
-        {
-            tChoix[pos]->decisionResp = 1;
-            return;
-        }
-        if(saisie == 2)
-        {
-            tChoix[pos]->decisionCand = 2;
-            return;
-        }
-        if(saisie == 3)
-        {
-            tChoix[pos]->decisionCand = -1;
-            return;
-        }
-        if(saisie == 4)
-        {
-            return;
-        }
-    }
-    if(tChoix[pos]->decisionCand == 2) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
-    {                                  
-        printf("Votre décision est actuellement en attente\n\n");
-        printf("|---------------------------------------|\n");
-        printf("|       Que souhaitez-vous faire ?      |\n");
-        printf("|---------------------------------------|\n");
-        printf("| 1 Accepter la demande d'admission     |\n");
-        printf("| 2 Refuser la demande d'admission      |\n");
-        printf("| 3 Ne rien changer                     |\n");
-        printf("|---------------------------------------|\n");
-        printf("Saisie : ");
-        scanf("%d%*c", &saisie);
-        printf("\n");
-        if(saisie == 1)
-        {
-            tChoix[pos]->decisionResp = 1;
-            return;
-        }
-        if(saisie == 2)
-        {
-            tChoix[pos]->decisionCand = -1;
-            return;
-        }
-        if(saisie == 3)
-        {
-            return;
-        }
-    }
-}*/
+// void miseAJourChoixResp(Choix *tChoix[], int pos) /* Fontcion permettant de mettre à jour la décision d'un responsable d'admission concernant un candidat */
+// {
+//     int saisie;
+//     system("clear");
+//     if(tChoix[pos]->decisionCand == 0) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
+//     {                                  
+//         printf("Votre décision est actuellement en attente\n\n");
+//         printf("|---------------------------------------|\n");
+//         printf("|       Que souhaitez-vous faire ?      |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("| 1 Accepter la demande d'admission     |\n");
+//         printf("| 2 Mettre sur liste d'attente          |\n");
+//         printf("| 3 Refuser la demande d'admission      |\n");
+//         printf("| 4 Ne rien changer                     |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("Saisie : ");
+//         scanf("%d%*c", &saisie);
+//         printf("\n");
+//         if(saisie == 1)
+//         {
+//             tChoix[pos]->decisionResp = 1;
+//             return;
+//         }
+//         if(saisie == 2)
+//         {
+//             tChoix[pos]->decisionCand = 2;
+//             return;
+//         }
+//         if(saisie == 3)
+//         {
+//             tChoix[pos]->decisionCand = -1;
+//             return;
+//         }
+//         if(saisie == 4)
+//         {
+//             return;
+//         }
+//     }
+//     if(tChoix[pos]->decisionCand == 2)  /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
+//     {                                  
+//         printf("Votre décision est actuellement en attente\n\n");
+//         printf("|---------------------------------------|\n");
+//         printf("|       Que souhaitez-vous faire ?      |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("| 1 Accepter la demande d'admission     |\n");
+//         printf("| 2 Refuser la demande d'admission      |\n");
+//         printf("| 3 Ne rien changer                     |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("Saisie : ");
+//         scanf("%d%*c", &saisie);
+//         printf("\n");
+//         if(saisie == 1)
+//         {
+//             tChoix[pos]->decisionResp = 1;
+//             return;
+//         }
+//         if(saisie == 2)
+//         {
+//             tChoix[pos]->decisionCand = -1;
+//             return;
+//         }
+//         if(saisie == 3)
+//         {
+//             return;
+//         }
+//     }
+// }
 
 
 Candidat ** creerCandidat(Candidat *tCand[], int *tMax)
@@ -1471,7 +1467,7 @@ FileCand adjq(FileCand f, Candidat *c)
 	}
 	m->c = c;
 	m->suiv = NULL;
-	if(vide(f))
+	if(videFile(f))
 	{
 		f.t = m;
 		f.q = m;
@@ -1485,7 +1481,7 @@ FileCand adjq(FileCand f, Candidat *c)
 FileCand supt(FileCand f)
 {
 	MaillonCandidat *aux;
-	if(vide(f))
+	if(videFile(f))
 	{
 		printf("Opération interdite\n");
 		exit(1);
@@ -1503,7 +1499,7 @@ FileCand supt(FileCand f)
 
 Candidat * tete(FileCand f)
 {
-	if(vide(f))
+	if(videFile(f))
 	{
 		printf("File d'attente vide\n");
 		exit(1);
@@ -1511,7 +1507,7 @@ Candidat * tete(FileCand f)
 	return f.t->c;
 }
 
-int longueur(FileCand f)
+int longueurFile(FileCand f)
 {
 	int i = 0;
 	while(f.t != NULL)
@@ -1537,7 +1533,7 @@ int positionFileAttente(FileCand f, int numeroC)
 	return i;
 }
 
-bool vide(FileCand f)
+bool videFile(FileCand f)
 {
 	if(f.t == NULL && f.q == NULL)
 		return true;
@@ -1562,96 +1558,117 @@ void afficher(FileCand f)
 /************************************************************************************************************/
 /************************************************************************************************************/
 
-ListeDept listeDeptNouv(void) /*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
+ListeCand listeCandNouv(void) /*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
 {
-	ListeDept lDept;
-	lDept = NULL;
-	return lDept;
+	ListeCand lCand;
+	lCand = NULL;
+	return lCand;
 }
 
-ListeDept insererEntete(ListeDept lDept,Departement d) /*Permet d'insérer un MaillonDept en début d'une liste passée en paramètre puis renvoie cette même liste*/
+ListeCand insererCandEntete(ListeCand lCand,Candidat *c) /*Permet d'insérer un MaillonCand en début d'une liste passée en paramètre puis renvoie cette même liste*/
 {
-	MaillonDept *m; /* Création d'un pointeur vers une structure MaillonDept */
-	m = (MaillonDept *)malloc(sizeof(MaillonDept)); /* Allocation d'un espace mémoire pour le nouveau maillon */
+	MaillonCandidat *m; /* Création d'un pointeur vers une structure MaillonCand */
+	m = (MaillonCandidat *)malloc(sizeof(MaillonCandidat)); /* Allocation d'un espace mémoire pour le nouveau maillon */
 	if(m == NULL) 
 	{
-		printf("Problème d'allocation mémoire lors de l'insertion\n"); /* Message d'erreur en cas de problème de malloc */
+		printf("Problème d'allocation mémoire lors de l'insertion d'un candidat dans la liste d'admission\n"); /* Message d'erreur en cas de problème de malloc */
 		exit(1);
 	}
-	m->d = d; /* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
-	m->suiv = lDept;
+	m->c = c; /* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
+	m->suiv = lCand;
 	return m;
 }
 
-ListeDept insererDept(ListeDept lDept, Departement d) /* Permet d'insérer un maillon dans une liste donnée en paramètre dans l'ordre alpĥabétique/croissant et retourne cette liste */
+ListeCand insererCand(ListeCand lCand, Candidat *c) /* Permet d'insérer un maillon dans une liste donnée en paramètre dans l'ordre alphabétique/croissant et retourne cette liste */
 {
-	if(lDept == NULL) /* Si la liste est vide, insère le nouveau maillon en tête */
+	if(lCand == NULL) /* Si la liste est vide, insère le nouveau maillon en tête */
 	{
-		return insererEntete(lDept,d);
+		return insererCandEntete(lCand, c);
 	}
-	if(strcmp(d.dept, lDept->d.dept) < 0) /* Si le nom du département est inférieur à celui de la liste testé, le maillon est inséré en tête*/
+	if(c->numeroC < lCand->c->numeroC) /* Si le numéro de candidat est inférieur à celui de la liste testé, le maillon est inséré en tête*/
 	{
-		return insererEntete(lDept,d);
+		return insererCandEntete(lCand, c);
 	}
-	if(strcmp(d.dept,lDept->d.dept) == 0) /* Si le maillon existe déjà, retourne la liste sans changement */
+	if(c->numeroC == lCand->c->numeroC) /* Si le maillon existe déjà, retourne la liste sans changement */
 	{
-		printf("Département déjà présent dans cet IUT\n");
-		return lDept;
+		printf("Candidat déjà présent dans la liste\n");
+		return lCand;
 	}
-	lDept->suiv = insererDept(lDept->suiv,d); /* Si aucun cas précédent n'est respecté, recommence avec le maillon suivant de la liste */
-	return lDept;
+	lCand->suiv = insererCand(lCand->suiv, c); /* Si aucun cas précédent n'est respecté, recommence avec le maillon suivant de la liste */
+	return lCand;
 }
 
-ListeDept supprimerEntete(ListeDept lDept) /* Permet de supprimer un maillon en tête de la liste donnée en paramètre et retourne cette liste */
+ListeCand supprimerCandEntete(ListeCand lCand) /* Permet de supprimer un maillon en tête de la liste donnée en paramètre et retourne cette liste */
 {
-	ListeDept aux;
-	if(lDept == NULL) /* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
+	ListeCand aux;
+	if(lCand == NULL) /* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
 	{
 		printf("Opération interdite\n");
 		exit(1);
 	}
-	aux = lDept; /* On affecte l'adresse de la liste actuelle à une variable temporaire */
-	lDept = lDept->suiv; /* On supprime le maillon */
+	aux = lCand; /* On affecte l'adresse de la liste actuelle à une variable temporaire */
+	lCand = lCand->suiv; /* On supprime le maillon */
 	free(aux); /* On libère l'espace mémoire du maillon supprimer*/
-	return lDept;
+	return lCand;
 }
 
-ListeDept supprimerDept(ListeDept lDept, char *dep) /* Permet de supprimer un maillon d'une liste lDept passée en paramètre à partir de son attribut nom de département (dept) et retourne cette liste */
+ListeCand supprimerCand(ListeCand lCand, Candidat *c) /* Permet de supprimer un maillon d'une liste lDept passée en paramètre à partir de son attribut nom de département (dept) et retourne cette liste */
 {
-	if(lDept == NULL) /* La liste est vide, on la retourne sans changements */
+	if(lCand == NULL) /* La liste est vide, on la retourne sans changements */
 	{
-		return lDept;
+		return lCand;
 	}
-	if(strcmp(dep, lDept->d.dept) < 0) /* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
+	if(c->numeroC < lCand->c->numeroC) /* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
 	{
-		return lDept;
+		return lCand;
 	}
-	if(strcmp(dep,lDept->d.dept) == 0) /* Le maillon à supprimer est trouvé, on le supprime */
+	if(c->numeroC == lCand->c->numeroC) /* Le maillon à supprimer est trouvé, on le supprime */
 	{
-		return supprimerEntete(lDept);
+		return supprimerCandEntete(lCand);
 	}
-	lDept->suiv = supprimerDept(lDept->suiv,dep); /* Aucune des conditions précédentes n'a été respectée, on recommence avec le maillon suivant */
-	return lDept;
+	lCand->suiv = supprimerCand(lCand->suiv, c); /* Aucune des conditions précédentes n'a été respectée, on recommence avec le maillon suivant */
+	return lCand;
 }
 
-int longueur(ListeDept lDept) /* Permet d'obtenir la longueur d'une liste passée en paramètre et retourne le nombre de maillons */
+int longueur(ListeCand lCand) /* Permet d'obtenir la longueur d'une liste passée en paramètre et retourne le nombre de maillons */
 {
 	int compt = 0; /* On déclare un compteur pour compter le nombre de maillons */
-	while(lDept != NULL) /* Tant que la liste n'est pas vide, on incrémente le compteur de 1 et on passe au maillon suivant */
+	while(lCand != NULL) /* Tant que la liste n'est pas vide, on incrémente le compteur de 1 et on passe au maillon suivant */
 	{
 		compt = compt + 1;
-		lDept = lDept->suiv;
+		lCand = lCand->suiv;
 	}
 	return compt;
 }
 
-bool vide(ListeDept lDept) /* Permet de savoir si une liste est vide et retourne un booléen */
+bool videListe(ListeCand lCand) /* Permet de savoir si une liste est vide et retourne un booléen */
 {
-	if(lDept == NULL)
+	if(lCand == NULL)
 		return true;
 	return false;
 }
 
+ListeCand rechercherCandListe(ListeCand lCand, int numeroC, int *trouve)  /* Permet de recherche un maillon dans une liste de départements passée en paramètre pour ensuite renvoyer son adresse*/
+{
+	if(videListe(lCand)) /* Si la liste est vide, la variable trouve passée en pointeur prend la valeur 0 et on retourne la liste */
+	{
+		*trouve = 0;
+		return lCand;
+	}
+	if(numeroC < lCand->c->numeroC) /* Même procédé que la condition précédente si le département recherché n'est pas trouvé*/
+	{
+		*trouve = 0;
+		return lCand;
+	}
+	if(numeroC == lCand->c->numeroC) /* Si le département recherché est trouvé, trouve prend la valeur 1 et on retourne la liste */
+	{
+		*trouve = 1;
+		return lCand;
+	}
+	return rechercherCandListe(lCand->suiv, numeroC, trouve); /* Si aucune condition n'est respectée, renvoie la même recherche pour le maillon suivant */
+}
+
+
 
 /********************************** Fonction globale et menus ***********************************************/
 /************************************************************************************************************/

Commun.h

@@ -114,7 +114,7 @@ typedef struct maillonCand
 {
     Candidat *c;
     struct maillonCand *suiv;
-} MaillonCandidat;
+} MaillonCandidat, *ListeCand;
 
 typedef struct
 {
@@ -171,9 +171,19 @@ FileCand adjq(FileCand f, Candidat *c);
 FileCand supt(FileCand f);
 Candidat * tete(FileCand f);
 int longueurFile(FileCand f);
-bool vide(FileCand f);
+bool videFile(FileCand f);
 int positionFileAttente(FileCand f, int numeroC);
 
+/* Fonctions de liste d'admission */
+ListeCand listeCandNouv(void);
+ListeCand insererCandEntete(ListeCand lCand,Candidat *c);
+ListeCand insererCand(ListeCand lCand, Candidat *c);
+ListeCand supprimerCandEntete(ListeCand lCand);
+ListeCand supprimerCand(ListeCand lCand, Candidat *c);
+int longueurListe(ListeCand lCand);
+bool videListe(ListeCand lCand);
+ListeCand rechercherCandListe(ListeCand lCand, int numeroC, int *trouve);
+
 /* Fonctions globale, menus*/
-void globale(void);
-void menuCandidat(Candidat *tCand[], int tMax);
+void globale2(void);
+void menuCandidat2(Candidat *tCand[], int tMax);

J2sae.c

@@ -404,73 +404,73 @@ int miseAJourChoixCand(Choix *tChoix[], int nombreChoix) /* Fontcion permettant
 }
 
 
-/*void miseAJourChoixResp(Choix *tChoix[], int pos)  Fontcion permettant de mettre à jour la décision d'un responsable d'admission concernant un candidat 
-{
-    int saisie;
-    system("clear");
-    if(tChoix[pos]->decisionCand == 0)  Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire 
-    {                                  
-        printf("Votre décision est actuellement en attente\n\n");
-        printf("|---------------------------------------|\n");
-        printf("|       Que souhaitez-vous faire ?      |\n");
-        printf("|---------------------------------------|\n");
-        printf("| 1 Accepter la demande d'admission     |\n");
-        printf("| 2 Mettre sur liste d'attente          |\n");
-        printf("| 3 Refuser la demande d'admission      |\n");
-        printf("| 4 Ne rien changer                     |\n");
-        printf("|---------------------------------------|\n");
-        printf("Saisie : ");
-        scanf("%d%*c", &saisie);
-        printf("\n");
-        if(saisie == 1)
-        {
-            tChoix[pos]->decisionResp = 1;
-            return;
-        }
-        if(saisie == 2)
-        {
-            tChoix[pos]->decisionCand = 2;
-            return;
-        }
-        if(saisie == 3)
-        {
-            tChoix[pos]->decisionCand = -1;
-            return;
-        }
-        if(saisie == 4)
-        {
-            return;
-        }
-    }
-    if(tChoix[pos]->decisionCand == 2) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
-    {                                  
-        printf("Votre décision est actuellement en attente\n\n");
-        printf("|---------------------------------------|\n");
-        printf("|       Que souhaitez-vous faire ?      |\n");
-        printf("|---------------------------------------|\n");
-        printf("| 1 Accepter la demande d'admission     |\n");
-        printf("| 2 Refuser la demande d'admission      |\n");
-        printf("| 3 Ne rien changer                     |\n");
-        printf("|---------------------------------------|\n");
-        printf("Saisie : ");
-        scanf("%d%*c", &saisie);
-        printf("\n");
-        if(saisie == 1)
-        {
-            tChoix[pos]->decisionResp = 1;
-            return;
-        }
-        if(saisie == 2)
-        {
-            tChoix[pos]->decisionCand = -1;
-            return;
-        }
-        if(saisie == 3)
-        {
-            return;
-        }
-    }
-}*/
+// void miseAJourChoixResp(Choix *tChoix[], int pos) /* Fontcion permettant de mettre à jour la décision d'un responsable d'admission concernant un candidat */
+// {
+//     int saisie;
+//     system("clear");
+//     if(tChoix[pos]->decisionCand == 0) /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
+//     {                                  
+//         printf("Votre décision est actuellement en attente\n\n");
+//         printf("|---------------------------------------|\n");
+//         printf("|       Que souhaitez-vous faire ?      |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("| 1 Accepter la demande d'admission     |\n");
+//         printf("| 2 Mettre sur liste d'attente          |\n");
+//         printf("| 3 Refuser la demande d'admission      |\n");
+//         printf("| 4 Ne rien changer                     |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("Saisie : ");
+//         scanf("%d%*c", &saisie);
+//         printf("\n");
+//         if(saisie == 1)
+//         {
+//             tChoix[pos]->decisionResp = 1;
+//             return;
+//         }
+//         if(saisie == 2)
+//         {
+//             tChoix[pos]->decisionCand = 2;
+//             return;
+//         }
+//         if(saisie == 3)
+//         {
+//             tChoix[pos]->decisionCand = -1;
+//             return;
+//         }
+//         if(saisie == 4)
+//         {
+//             return;
+//         }
+//     }
+//     if(tChoix[pos]->decisionCand == 2)  /* Affichage d'un menu adapté pour chaque cas ; le candidat peut choisir entre deux option ou bien ne rien faire */
+//     {                                  
+//         printf("Votre décision est actuellement en attente\n\n");
+//         printf("|---------------------------------------|\n");
+//         printf("|       Que souhaitez-vous faire ?      |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("| 1 Accepter la demande d'admission     |\n");
+//         printf("| 2 Refuser la demande d'admission      |\n");
+//         printf("| 3 Ne rien changer                     |\n");
+//         printf("|---------------------------------------|\n");
+//         printf("Saisie : ");
+//         scanf("%d%*c", &saisie);
+//         printf("\n");
+//         if(saisie == 1)
+//         {
+//             tChoix[pos]->decisionResp = 1;
+//             return;
+//         }
+//         if(saisie == 2)
+//         {
+//             tChoix[pos]->decisionCand = -1;
+//             return;
+//         }
+//         if(saisie == 3)
+//         {
+//             return;
+//         }
+//     }
+// }
 
 
 Candidat ** creerCandidat(Candidat *tCand[], int *tMax)
@@ -614,7 +614,7 @@ FileCand adjq(FileCand f, Candidat *c)
     }
     m->c = c;
     m->suiv = NULL;
-    if(vide(f))
+    if(videFile(f))
     {
         f.t = m;
         f.q = m;
@@ -628,7 +628,7 @@ FileCand adjq(FileCand f, Candidat *c)
 FileCand supt(FileCand f)
 {
     MaillonCandidat *aux;
-    if(vide(f))
+    if(videFile(f))
     {
         printf("Opération interdite\n");
         exit(1);
@@ -646,7 +646,7 @@ FileCand supt(FileCand f)
 
 Candidat * tete(FileCand f)
 {
-    if(vide(f))
+    if(videFile(f))
     {
         printf("File d'attente vide\n");
         exit(1);
@@ -654,7 +654,7 @@ Candidat * tete(FileCand f)
     return f.t->c;
 }
 
-int longueur(FileCand f)
+int longueurFile(FileCand f)
 {
     int i = 0;
     while(f.t != NULL)
@@ -680,7 +680,7 @@ int positionFileAttente(FileCand f, int numeroC)
     return i;
 }
 
-bool vide(FileCand f)
+bool videFile(FileCand f)
 {
     if(f.t == NULL && f.q == NULL)
         return true;
@@ -705,102 +705,123 @@ void afficher(FileCand f)
 /************************************************************************************************************/
 /************************************************************************************************************/
 
-ListeDept listeDeptNouv(void) /*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
+ListeCand listeCandNouv(void) /*Permet de créer un liste vide puis la retourne à la fonction appelante.*/
 {
-    ListeDept lDept;
-    lDept = NULL;
-    return lDept;
+    ListeCand lCand;
+    lCand = NULL;
+    return lCand;
 }
 
-ListeDept insererEntete(ListeDept lDept,Departement d) /*Permet d'insérer un MaillonDept en début d'une liste passée en paramètre puis renvoie cette même liste*/
+ListeCand insererCandEntete(ListeCand lCand,Candidat *c) /*Permet d'insérer un MaillonCand en début d'une liste passée en paramètre puis renvoie cette même liste*/
 {
-    MaillonDept *m; /* Création d'un pointeur vers une structure MaillonDept */
-    m = (MaillonDept *)malloc(sizeof(MaillonDept)); /* Allocation d'un espace mémoire pour le nouveau maillon */
+    MaillonCandidat *m; /* Création d'un pointeur vers une structure MaillonCand */
+    m = (MaillonCandidat *)malloc(sizeof(MaillonCandidat)); /* Allocation d'un espace mémoire pour le nouveau maillon */
     if(m == NULL) 
     {
-        printf("Problème d'allocation mémoire lors de l'insertion\n"); /* Message d'erreur en cas de problème de malloc */
+        printf("Problème d'allocation mémoire lors de l'insertion d'un candidat dans la liste d'admission\n"); /* Message d'erreur en cas de problème de malloc */
         exit(1);
     }
-    m->d = d; /* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
-    m->suiv = lDept;
+    m->c = c; /* Affecte le département passé en paramètre à l'attribut d du nouveau maillon */
+    m->suiv = lCand;
     return m;
 }
 
-ListeDept insererDept(ListeDept lDept, Departement d) /* Permet d'insérer un maillon dans une liste donnée en paramètre dans l'ordre alpĥabétique/croissant et retourne cette liste */
+ListeCand insererCand(ListeCand lCand, Candidat *c) /* Permet d'insérer un maillon dans une liste donnée en paramètre dans l'ordre alphabétique/croissant et retourne cette liste */
 {
-    if(lDept == NULL) /* Si la liste est vide, insère le nouveau maillon en tête */
+    if(lCand == NULL) /* Si la liste est vide, insère le nouveau maillon en tête */
     {
-        return insererEntete(lDept,d);
+        return insererCandEntete(lCand, c);
     }
-    if(strcmp(d.dept, lDept->d.dept) < 0) /* Si le nom du département est inférieur à celui de la liste testé, le maillon est inséré en tête*/
+    if(c->numeroC < lCand->c->numeroC) /* Si le numéro de candidat est inférieur à celui de la liste testé, le maillon est inséré en tête*/
     {
-        return insererEntete(lDept,d);
+        return insererCandEntete(lCand, c);
     }
-    if(strcmp(d.dept,lDept->d.dept) == 0) /* Si le maillon existe déjà, retourne la liste sans changement */
+    if(c->numeroC == lCand->c->numeroC) /* Si le maillon existe déjà, retourne la liste sans changement */
     {
-        printf("Département déjà présent dans cet IUT\n");
-        return lDept;
+        printf("Candidat déjà présent dans la liste\n");
+        return lCand;
     }
-    lDept->suiv = insererDept(lDept->suiv,d); /* Si aucun cas précédent n'est respecté, recommence avec le maillon suivant de la liste */
-    return lDept;
+    lCand->suiv = insererCand(lCand->suiv, c); /* Si aucun cas précédent n'est respecté, recommence avec le maillon suivant de la liste */
+    return lCand;
 }
 
-ListeDept supprimerEntete(ListeDept lDept) /* Permet de supprimer un maillon en tête de la liste donnée en paramètre et retourne cette liste */
+ListeCand supprimerCandEntete(ListeCand lCand) /* Permet de supprimer un maillon en tête de la liste donnée en paramètre et retourne cette liste */
 {
-    ListeDept aux;
-    if(lDept == NULL) /* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
+    ListeCand aux;
+    if(lCand == NULL) /* Si la liste est vide, quitte le programme car cela provoquerait une erreur */
     {
         printf("Opération interdite\n");
         exit(1);
     }
-    aux = lDept; /* On affecte l'adresse de la liste actuelle à une variable temporaire */
-    lDept = lDept->suiv; /* On supprime le maillon */
+    aux = lCand; /* On affecte l'adresse de la liste actuelle à une variable temporaire */
+    lCand = lCand->suiv; /* On supprime le maillon */
     free(aux); /* On libère l'espace mémoire du maillon supprimer*/
-    return lDept;
+    return lCand;
 }
 
-ListeDept supprimerDept(ListeDept lDept, char *dep) /* Permet de supprimer un maillon d'une liste lDept passée en paramètre à partir de son attribut nom de département (dept) et retourne cette liste */
+ListeCand supprimerCand(ListeCand lCand, Candidat *c) /* Permet de supprimer un maillon d'une liste lDept passée en paramètre à partir de son attribut nom de département (dept) et retourne cette liste */
 {
-    if(lDept == NULL) /* La liste est vide, on la retourne sans changements */
+    if(lCand == NULL) /* La liste est vide, on la retourne sans changements */
     {
-        return lDept;
+        return lCand;
     }
-    if(strcmp(dep, lDept->d.dept) < 0) /* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
+    if(c->numeroC < lCand->c->numeroC) /* Le maillon à supprimer n'existe pas, on retourne la liste sans changement */
     {
-        return lDept;
+        return lCand;
     }
-    if(strcmp(dep,lDept->d.dept) == 0) /* Le maillon à supprimer est trouvé, on le supprime */
+    if(c->numeroC == lCand->c->numeroC) /* Le maillon à supprimer est trouvé, on le supprime */
     {
-        return supprimerEntete(lDept);
+        return supprimerCandEntete(lCand);
     }
-    lDept->suiv = supprimerDept(lDept->suiv,dep); /* Aucune des conditions précédentes n'a été respectée, on recommence avec le maillon suivant */
-    return lDept;
+    lCand->suiv = supprimerCand(lCand->suiv, c); /* Aucune des conditions précédentes n'a été respectée, on recommence avec le maillon suivant */
+    return lCand;
 }
 
-int longueur(ListeDept lDept) /* Permet d'obtenir la longueur d'une liste passée en paramètre et retourne le nombre de maillons */
+int longueur(ListeCand lCand) /* Permet d'obtenir la longueur d'une liste passée en paramètre et retourne le nombre de maillons */
 {
     int compt = 0; /* On déclare un compteur pour compter le nombre de maillons */
-    while(lDept != NULL) /* Tant que la liste n'est pas vide, on incrémente le compteur de 1 et on passe au maillon suivant */
+    while(lCand != NULL) /* Tant que la liste n'est pas vide, on incrémente le compteur de 1 et on passe au maillon suivant */
     {
         compt = compt + 1;
-        lDept = lDept->suiv;
+        lCand = lCand->suiv;
     }
     return compt;
 }
 
-bool vide(ListeDept lDept) /* Permet de savoir si une liste est vide et retourne un booléen */
+bool videListe(ListeCand lCand) /* Permet de savoir si une liste est vide et retourne un booléen */
 {
-    if(lDept == NULL)
+    if(lCand == NULL)
         return true;
     return false;
 }
 
+ListeCand rechercherCandListe(ListeCand lCand, int numeroC, int *trouve)  /* Permet de recherche un maillon dans une liste de départements passée en paramètre pour ensuite renvoyer son adresse*/
+{
+    if(videListe(lCand)) /* Si la liste est vide, la variable trouve passée en pointeur prend la valeur 0 et on retourne la liste */
+    {
+        *trouve = 0;
+        return lCand;
+    }
+    if(numeroC < lCand->c->numeroC) /* Même procédé que la condition précédente si le département recherché n'est pas trouvé*/
+    {
+        *trouve = 0;
+        return lCand;
+    }
+    if(numeroC == lCand->c->numeroC) /* Si le département recherché est trouvé, trouve prend la valeur 1 et on retourne la liste */
+    {
+        *trouve = 1;
+        return lCand;
+    }
+    return rechercherCandListe(lCand->suiv, numeroC, trouve); /* Si aucune condition n'est respectée, renvoie la même recherche pour le maillon suivant */
+}
+
+
 
 /********************************** Fonction globale et menus ***********************************************/
 /************************************************************************************************************/
 /************************************************************************************************************/
 
-void globale(void) /* Permet de gérer l'exécution du programme */
+void globale2(void) /* Permet de gérer l'exécution du programme */
 {
     int tMax, pos, trouve, i = 0, j, mini = i;
     Candidat **tCand, c, **aux, *temp; /* Initialisation du tableau de candidats */
@@ -824,12 +845,12 @@ void globale(void) /* Permet de gérer l'exécution du programme */
         tCand[i] = tCand[mini];
         tCand[mini] = temp;
     }
-    //menuCandidat(tCand, tMax); /* Appel du menu adapté au candidat */
+    //menuCandidat2(tCand, tMax); /* Appel du menu adapté au candidat */
     afficherCandChoix(aux, tMax);
     sauvegarder(tCand, tMax); /* Sauvegarde du tableau de candidats */
 }
 
-void menuCandidat(Candidat *tCand[], int tMax) /* Fonction affichant un menu adapté pour un candidat */
+void menuCandidat2(Candidat *tCand[], int tMax) /* Fonction affichant un menu adapté pour un candidat */
 {
     int pos,trouve, saisie, i, numeroC;
     system("clear");

J2sae.h

@@ -48,7 +48,7 @@ typedef struct maillonCand
 {
     Candidat *c;
     struct maillonCand *suiv;
-} MaillonCandidat;
+} MaillonCandidat, *ListeCand;
 
 typedef struct
 {
@@ -105,9 +105,19 @@ FileCand adjq(FileCand f, Candidat *c);
 FileCand supt(FileCand f);
 Candidat * tete(FileCand f);
 int longueurFile(FileCand f);
-bool vide(FileCand f);
+bool videFile(FileCand f);
 int positionFileAttente(FileCand f, int numeroC);
 
+/* Fonctions de liste d'admission */
+ListeCand listeCandNouv(void);
+ListeCand insererCandEntete(ListeCand lCand,Candidat *c);
+ListeCand insererCand(ListeCand lCand, Candidat *c);
+ListeCand supprimerCandEntete(ListeCand lCand);
+ListeCand supprimerCand(ListeCand lCand, Candidat *c);
+int longueurListe(ListeCand lCand);
+bool videListe(ListeCand lCand);
+ListeCand rechercherCandListe(ListeCand lCand, int numeroC, int *trouve);
+
 /* Fonctions globale, menus*/
 void globale(void);
 void menuCandidat(Candidat *tCand[], int tMax);