reoganisation, suppression de qq erreures et makefile effectif

Makefile

@@ -2,12 +2,15 @@ NAME = SAE2
 
 RM = rm -rf
 CC = gcc
-CFLAGS = -Wall -Wextra -Werror
+CFLAGS = -Wall -Wextra
 
 SRC_DIR = srcs
 OBJ_DIR = obj
 
-SRC_FILES = $(SRC_DIR)/main.c
+SRC_FILES =	$(SRC_DIR)/structures.c \
+		$(SRC_DIR)/charge.c \
+		$(SRC_DIR)/sort.c \
+		$(SRC_DIR)/main.c
 
 OBJ_FILES = $(SRC_FILES:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)
 
@@ -31,5 +34,3 @@ fclean: clean
 re: fclean all
 
 .PHONY: all clean fclean re
-
-

includes/charge.h

@@ -1,10 +1,37 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
 #include "structures.h"
+#include <stdio.h>
+
+// Chargements
+
+char		*readAdress(FILE *flot);
+Devis		loadDevis(Offre *tabTravaux[]);
+Tache		**loadTaches(Offre *tabTravaux[]);
+Precedence	*loadPrec(int *tmax, int *tlog);
+
+
+// Recherches et tri
+
+int		rechTravaux(char *travauxName, Offre *tabTravaux[]);
+void		minTravaux(Offre *tabTravaux[]);
+void		freeListeDevis(ListeDevis *ldevis);
+void		fusionDevisElements(ListeDevis *R, int *tlogR, ListeDevis *S, int *tlogS, ListeDevis *mergedList, ListeDevis *last, int *k);
+void		gestionElementsRestants(ListeDevis *mergedList, ListeDevis *last, ListeDevis *source, int *tlogSource, int *k);
+void		fusionMaillonDevis(ListeDevis R, int tlogR, ListeDevis S, int tlogS, ListeDevis *T);
+void		triFusionListeDevis(ListeDevis *ldevis, int tlog);
+
+// Foncctions de base 
 
-char *readAdress(FILE *flot);
-Tache **chargeTaches(Offre *tabTravaux[]);
-Precedence *loadPrec(int *tmax);
-int nombrePred(char travaux[], Precedence prec[], int tlog);
-Liste lstSucc(char travaux[], Precedence prec[], int tlog);
+int		lenListeDevis(ListeDevis l);
+int		nombrePred(char travaux[], Precedence prec[], int tlog);
+void		displayDevis(Devis d);
+void		displayOffre(Offre *o);
+void		displayListeDevis(ListeDevis l);
+Offre		newOffre(char *travauxName);
+Booleen		emptyListe(ListeDevis l);
+Booleen		emptyOffre(Offre *o);
+Liste		newListe(void);
+Liste		insertSucc(Liste l, char travaux[]);
+Liste		lstSucc(char travaux[], Precedence prec[], int tlog);
+ListeDevis	delete(ListeDevis l);
+ListeDevis	insert(ListeDevis l, Devis d);
+ListeDevis	newListeDevis(void);

includes/main.h

@@ -1,2 +1,9 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include "charge.h"
+
 #define tmaxTravaux 8
 

includes/structures.h

@@ -1,8 +1,3 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
-
 typedef struct 
 {
 	char nomE[32];
@@ -48,32 +43,4 @@ typedef struct
 {
 	char travauxPrec[30];
 	char travauxSucc[30];
-} Precedence;
-
-//Devis
-
-void displayDevis(Devis d);
-Devis readDevis(Offre *tabTravaux[]);
-
-//ListeDevis
-
-ListeDevis 	newListeDevis(void);
-ListeDevis 	delete(ListeDevis l);
-ListeDevis 	insert(ListeDevis l, Devis d);
-ListeDevis  sortListeDevis(ListeDevis l);
-Booleen 	emptyListe(ListeDevis l);
-int 		lenListeDevis(ListeDevis l);
-void 		displayListeDevis(ListeDevis l);
-
-//Offre
-
-Offre newOffre(char *travauxName);
-Booleen 	emptyOffre(Offre o);
-void 		displayOffre(Offre o);
-int 		rechTravaux(char travauxName[], Offre *tabTravaux[]);
-void minTravaux(Offre *tabTravaux[]);
-
-//Liste successeurs
-
-Liste newListe(void);
-Liste insertSucc(Liste l, char travaux[]);
+} Precedence;

srcs/charge.c

@@ -1,6 +1,8 @@
-#include "../includes/charge.h"
 #include "../includes/main.h"
 
+/*---------------devis---------------*/
+
+// Chargement de l'adresse depuis un fichier
 char *readAdress(FILE *flot)
 {
 	char *adresse, *s, aux[5];
@@ -10,7 +12,7 @@ char *readAdress(FILE *flot)
 
 	while (adresse[i]!='\n')
 	{
-		if (i==tmax)
+		if (i==tmax - 1)
 		{
 			tmax+=5;
 			s = (char *)realloc(adresse, tmax*sizeof(char));
@@ -29,37 +31,32 @@ char *readAdress(FILE *flot)
 	return adresse;
 }
 
-Precedence *loadPrec(int *tmax, int *tlog)
+// Chargement d'un devis depuis un fichier
+Devis loadDevis(Offre *tabTravaux[])
 {
-	FILE *prec;
-	Precedence *tabP, *s;
-	prec=fopen("précédence.txt", "r");
-	if (prec == NULL)
-	{
-		printf("\033[0;31mErreur: \033[0mouverture de 'précédence.txt'\n");
-	}
-	tabP = (Precedence *)malloc((*tmax) * sizeof(Precedence));
-	while(!feof(prec))
+	Devis d;
+	FILE *devisFile;
+	devisFile = fopen("../devis/txt", "r");
+	char travaux[16];
+	int index;
+	scanf("%s", travaux);
+	index = rechTravaux(travaux, tabTravaux);
+	if (index==-1)
 	{
-		if(*tlog==*tmax)
-		{
-			(*tmax)+=5;
-			s = (Precedence *)malloc((*tmax) * sizeof(Precedence));
-			if (s==NULL)
-			{
-				printf("\033[0;31mErreur: \033[0mreallocation pour fichier précédence\n");
-				exit(1);
-			}
-			tabP = s;
-		}
-		fscanf(prec, "%s%s", tabP[*tlog-1].travauxPrec, tabP[*tlog-1].travauxSucc);
-		(*tlog)++;
+		printf("\033[0;31mErreur: \033[0mCes travaux ne sont pas prévus !\n");
+		exit(1);
 	}
-	fclose(prec);
-	return tabP;
+	fgets(d.nomE, 32, devisFile);
+	d.nomE[strlen(d.nomE)-1] = '\0';
+	d.adresse = readAdress(devisFile);
+	fscanf(devisFile, "%d\n%d\n%d", &d.capital, &d.duree, &d.prix);
+	fclose(devisFile);
+	return d;
 }
 
-Tache **chargeTaches(Offre *tabTravaux[])
+
+// Chargement des tâches depuis un fichier pour chaque offre
+Tache **loadTaches(Offre *tabTravaux[])
 {
 	Precedence *prec;
 	int i, tmaxPrec=5, tlogPrec;
@@ -68,7 +65,7 @@ Tache **chargeTaches(Offre *tabTravaux[])
 	if (tabTache == NULL)
 	{
 		printf("\033[0;31mErreur: \033[0mmalloc tableau tache\n");
-			exit(1);
+		exit(1);
 	}
 	for (i=0; i<tmaxTravaux; i++)
 	{
@@ -94,21 +91,36 @@ Tache **chargeTaches(Offre *tabTravaux[])
 	return tabTache;
 }
 
-int nombrePred(char travaux[], Precedence prec[], int tlog)
-{
-	int nbPred, i;
-	for (i=0; i<tlog; i++)
-		if (strcmp(travaux, prec[i].travauxSucc)==0)
-			nbPred++;
-	return nbPred;
-}
+/*--------------precedences--------------*/
 
-Liste lstSucc(char travaux[], Precedence prec[], int tlog)
+// Chargement des précédences depuis un fichier
+Precedence *loadPrec(int *tmax, int *tlog)
 {
-	Liste succ = newListe();
-	int i;
-	for (i=0; i<tlog; i++)
-		if(strcmp(travaux, prec[i].travauxPrec)==0)
-			succ=insertSucc(succ, prec[i].travauxSucc);
-	return succ;
-}
+	FILE *prec;
+	Precedence *tabP, *s;
+	prec=fopen("../files/précédence.txt", "r");
+	if (prec == NULL)
+	{
+		printf("\033[0;31mErreur: \033[0mouverture de 'précédence.txt'\n");
+		exit(1);
+	}
+	tabP = (Precedence *)malloc((*tmax) * sizeof(Precedence));
+	while(!feof(prec))
+	{
+		if(*tlog==*tmax)
+		{
+			(*tmax)+=5;
+			s = (Precedence *)malloc((*tmax) * sizeof(Precedence));
+			if (s==NULL)
+			{
+				printf("\033[0;31mErreur: \033[0mreallocation pour fichier précédence\n");
+				exit(1);
+			}
+			tabP = s;
+		}
+		fscanf(prec, "%s%s", tabP[*tlog-1].travauxPrec, tabP[*tlog-1].travauxSucc);
+		(*tlog)++;
+	}
+	fclose(prec);
+	return tabP;
+}

srcs/main.c

@@ -1,6 +1,56 @@
 #include "../includes/main.h"
 
-int main(void)
+int main()
 {
+    // Chargement des fichiers
+    Offre tabTravaux[tmaxTravaux];
+    Offre *tabTravauxPtr[tmaxTravaux];
 
-}
+    for (int i = 0; i < tmaxTravaux; i++)
+    {
+        char travauxName[30];
+	printf("nom du travail a effectuer : ");
+        scanf("%s", travauxName);
+        tabTravaux[i] = newOffre(travauxName);
+        tabTravauxPtr[i] = &tabTravaux[i];
+    }
+
+    // Affichage des offres avant le tri
+    for (int i = 0; i < tmaxTravaux; i++)
+    {
+        displayOffre(&tabTravaux[i]);
+    }
+
+    // Tri des offres
+    for (int i = 0; i < tmaxTravaux; i++)
+    {
+        triFusionListeDevis(&(tabTravaux[i].ldevis), lenListeDevis(tabTravaux[i].ldevis));
+    }
+
+    // Affichage des offres après le tri
+    for (int i = 0; i < tmaxTravaux; i++)
+    {
+        displayOffre(&tabTravaux[i]);
+    }
+
+    // Chargement du fichier précédence
+    int tmaxPrec = 5, tlogPrec;
+    Precedence *prec = loadPrec(&tmaxPrec, &tlogPrec);
+
+    // Affichage du fichier précédence
+    for (int i = 0; i < tlogPrec; i++)
+    {
+        printf("%s -> %s\n", prec[i].travauxPrec, prec[i].travauxSucc);
+    }
+
+    // Chargement des tâches en utilisant le tableau temporaire de pointeurs Offre *
+    Tache **tabTache = loadTaches(tabTravauxPtr);
+
+    // Affichage des tâches
+    for (int i = 0; i < tmaxTravaux; i++)
+    {
+        printf("Tache: %s, Duree: %d, NbPred: %d\n", tabTache[i]->tache, tabTache[i]->duree, tabTache[i]->nbPred);
+    }
+
+    return 0;
+}

srcs/part4.c

@@ -1,59 +1 @@
-#include "../includes/structures.h"
-
-void calculerDatesDebut()
-{
-	int	file[MAX_TACHES];
-	int	dateActuelle;
-	int	indiceSucc;
-	int	indeTache;
-	int	deb;
-	int	fin;
-	int	i;
-	int	j;
-
-	initialiserFile(file, &deb, &fin);
-
-	for (i = 0; i < nbTaches; i++)
-		if (tableauTaches[i].nbPred == 0)
-			enfiler(file, &fin, i);
-
-	dateActuelle = 0;
-	while (!estVide(deb, fin))
-	{
-		indiceTache = defiler(file, &deb);
-		Tache *t = &tableauTaches[indiceTache];
-
-		t->dateDebut = dateActuelle;
-		t->traite = true;
-		
-		for (j = 0; j < t->nbSucc; j++)
-		{
-			indiceSucc = t->successeurs[j];
-			Tache *succ = &tableauTaches[indiceSucc];
-			if (succ->dateDebut > dateActuelle + t->duree)
-				succ->dateDebut = succ->dateDebut;
-			else
-				succ->dateDebut = dateActuelle + t->duree;
-			succ->nbPred--;
-			
-			if (succ->nbPred == 0)
-				enfiler(file, &fin, indiceSucc);
-		}
-
-		dateActuelle = INT_MAX;
-		for (i = 0; i < nbTaches; i++)
-			if (!tableauTaches[i].traite && tableauTaches[i].dateDebut < dateActuelle)
-				dateActuelle = tableauTaches[i].dateDebut;
-	}
-	
-	for (i = 0; i < nbTaches; i++)
-		if (!tableauTaches[i].traite)
-			printf("Toutes les taches n'ont pas ete executees\n");
-			exit(1);
-}
-
-int	main()
-{
-    return (0);
-}
-
+#include "../includes/main.h"

srcs/sort.c

@@ -1,16 +1,76 @@
-#include "../includes/structures.h"
+#include "../includes/main.h"
 
-/*
-	j'ai essayer de faire comme le prof pour les noms de variable,
-	je crois que c completement loupe :)
-*/
+/*-------------recherches-------------*/
 
-/*---------------------------------------------------------------------------*/
+// Recherche d'une offre dans le tableau de travaux
+// Retourne l'indice de l'offre dans le tableau si elle est trouvée, sinon retourne -1
+int rechTravaux(char *travauxName, Offre *tabTravaux[])
+{
+	//On utilise la taille max de travaux car travaux est un tableau constant, sa taille max est égale à sa taille logique.
+	int deb=0, end=tmaxTravaux-1, mid;
+	while(deb<=end)
+	{
+		mid = (deb+end) /2;
+		if (strcmp(travauxName, tabTravaux[mid]->travaux)==0)
+			return mid;
+		if (strcmp(travauxName, tabTravaux[mid]->travaux) < 0)
+			end=mid-1;
+		else
+			deb=mid+1;
+	}
+	return -1;
+}
+
+// Recherche et garde la meilleure offre par travaux dans le tableau
+// Affiche chaque offre gardee avec le devis ayant le prix le plus bas
+void minTravaux(Offre *tabTravaux[])
+{
+	int i;
+	ListeDevis l, minl;
+	for (i=0; i<tmaxTravaux; i++)
+	{
+		l=tabTravaux[i]->ldevis;
+		minl=l;
+		while(l)
+		{
+			if(l->dev.prix < minl->dev.prix)
+			{
+				l=delete(minl);
+				minl=l;
+			}
+			else 
+				l=delete(l);
+			l=l->suiv;
+		}
+		displayOffre(tabTravaux[i]);
+	}
+}
+
+
+/*---------------tri------------------*/
+
+//on la met dans struct.c ?
+
+// Libère la mémoire d'une liste de devis
+void 	freeListeDevis(ListeDevis *ldevis)
+{
+	ListeDevis current = *ldevis;
+	ListeDevis next;
+
+	while (current) 
+	{
+		next = current->suiv;
+		free(current);
+		current = next;
+	}
+	*ldevis = NULL;
+}
 
-// boucle principale (je la trouve pas jolie, est ce qu'on la met dans fusionMaillonDevis meme si ce sera plus somple a expliquer ?)
+// Boucle principale de fusion de listes de devis
 void	fusionDevisElements(ListeDevis *R, int *tlogR, ListeDevis *S, int *tlogS, ListeDevis *mergedList, ListeDevis *last, int *k)
 {
 	ListeDevis	*current;
+
 	while (*tlogR > 0 && *tlogS > 0)
 	{
 		if (strcmp((*R)->dev.nomE, (*S)->dev.nomE) < 0)
@@ -40,7 +100,7 @@ void	fusionDevisElements(ListeDevis *R, int *tlogR, ListeDevis *S, int *tlogS, L
 	}
 }
 
-// fin des iteration principales
+// Gère les éléments restants après les itérations principales de fusion
 void	gestionElementsRestants(ListeDevis *mergedList, ListeDevis *last, ListeDevis *source, int *tlogSource, int *k)
 {
 	while (*tlogSource > 0)
@@ -60,7 +120,7 @@ void	gestionElementsRestants(ListeDevis *mergedList, ListeDevis *last, ListeDevi
 	}
 }
 
-// fusion de maillons 
+// Fusionne deux listes de devis triées en une seule liste triée
 void	fusionMaillonDevis(ListeDevis R, int tlogR, ListeDevis S, int tlogS, ListeDevis *T)
 {
 	ListeDevis	last;
@@ -70,15 +130,14 @@ void	fusionMaillonDevis(ListeDevis R, int tlogR, ListeDevis S, int tlogS, ListeD
 	last = NULL;
 	mergedList = NULL;
 	k = 0;
-
 	fusionDevisElements			(&R, &tlogR, &S, &tlogS, &mergedList, &last, &k);
 	gestionElementsRestants			(&mergedList, &last, &R, &tlogR, &k);
 	gestionElementsRestants			(&mergedList, &last, &S, &tlogS, &k);
-
+	freeListeDevis(T);
 	*T = mergedList;
 }
 
-// tri fusion sur les struct 
+// Tri fusion sur une liste de devis
 void	triFusionListeDevis(ListeDevis *ldevis, int tlog)
 {
 	ListeDevis	p;
@@ -96,57 +155,9 @@ void	triFusionListeDevis(ListeDevis *ldevis, int tlog)
 	}
 	qTemp = p->suiv;
 	p->suiv = NULL;
-
 	triFusionListeDevis(ldevis, tlog / 2);
 	triFusionListeDevis(&qTemp, tlog - tlog / 2);
-	
 	ListeDevis mergedList = NULL;
 	fusionMaillonDevis(*ldevis, tlog / 2, qTemp, tlog - tlog / 2, &mergedList);
-
 	*ldevis = mergedList;
 }
-
-//est ce qu'on supprime tout les elements de la liste chainee ou juste les elements de la longueure logique ?
-void	freeListeDevis(ListeDevis *ldevis, int *tlog)
-{
-	ListeDevis	pos;
-	pos = *ldevis;
-	while (pos)
-	{
-		ListeDevis suiv = pos->suiv;
-		free(pos);
-		pos = suiv;
-	}
-	*ldevis = NULL;
-	*tlog = 0;
-}
-
-/*
-int	main(void)
-{
-	Offre offre1 = {"Travaux1", NULL};
-	offre1.ldevis = (ListeDevis)malloc(sizeof(struct maillonDevis));
-	offre1.ldevis->dev = (Devis){"Devis6", "Adresse1", 100, 5};
-	offre1.ldevis->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
-	offre1.ldevis->suiv->dev = (Devis){"Devis3", "Adresse3", 80, 3};
-	offre1.ldevis->suiv->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
-	offre1.ldevis->suiv->suiv->dev = (Devis){"Devis8", "Adresse2", 120, 7};
-	offre1.ldevis->suiv->suiv->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
-	offre1.ldevis->suiv->suiv->suiv->dev = (Devis){"Devis5", "Adresse5", 90, 4};
-	offre1.ldevis->suiv->suiv->suiv->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
-	offre1.ldevis->suiv->suiv->suiv->suiv->dev = (Devis){"Devis2", "Adresse2", 110, 6};
-	offre1.ldevis->suiv->suiv->suiv->suiv->suiv = NULL;
-	int tlog = 5;
-
-	printf("Avant le tri : \n");
-	afficherOffre(&offre1);
-
-	triFusionListeDevis(&offre1.ldevis, tlog);
-
-	printf("\nApres le tri : \n");
-	afficherOffre(&offre1);
-
-	freeListeDevis(&offre1.ldevis, &tlog);
-	return (0);
-}
-*/

srcs/structures.c

@@ -1,59 +1,45 @@
-#include "../includes/charge.h"
 #include "../includes/main.h"
 
-//Devis
+/*----------initialisations ----------*/
 
-void displayDevis(Devis d)
+// Initialise une liste de devis
+ListeDevis newListeDevis(void)
 {
-	printf("%s\t%s\t%d\t%d\t%d\n", d.nomE, d.adresse, d.capital, d.duree, d.prix);
+	return NULL;
 }
 
+// Initialise une liste de travaux
+Liste newListe(void)
+{
+	return NULL;
+}
 
-Devis readDevis(Offre *tabTravaux[])
+// Initialise une nouvelle offre
+Offre newOffre(char *travauxName)
 {
-	Devis d;
-	FILE *devisFile;
-	devisFile = fopen("devis.txt", "r");
-	char travaux[16];
-	int index;
-	scanf("%s", travaux);
-	index = rechTravaux(travaux, tabTravaux);
-	if (index==-1)
-	{
-		printf("\033[0;31mErreur: \033[0mCes travaux ne sont pas prévus !\n");
-		exit(1);
-	}
-	fgets(d.nomE, 32, devisFile);
-	d.nomE[strlen(d.nomE)-1] = '\0';
-	readAdress(devisFile);
-	fscanf(devisFile, "%d\n%d\n%d", d.capital, d.duree, d.prix);
-	fclose(devisFile);
-	return d;
+	Offre o;
+	strcpy(o.travaux, travauxName);
+	o.ldevis=newListeDevis();
+	return o;
 }
 
-//ListeDevis
+/*------------verifications------------*/
 
-ListeDevis newListeDevis(void)
+// Verifie l'integrite d'une liste de devis
+Booleen emptyListe(ListeDevis l)
 {
-	return NULL;
+	return l==NULL;
 }
 
-
-ListeDevis delete(ListeDevis l)
+// Vérifie l'intégrité de l'offre
+Booleen emptyOffre(Offre *o)
 {
-	MaillonDevis *md;
-	if (l==NULL)
-	{
-		printf("\033[0;31mErreur: \033[0msuppression dans une liste vide\n");
-		exit(1);
-	}
-	md=l;
-	l=l->suiv;
-	free(md);
-	return l;
+	return emptyListe(o->ldevis);
 }
 
+/*-------------insertions---------------*/
 
+// Insere un devis dans la liste de devis
 ListeDevis insert(ListeDevis l, Devis d)
 {
 	MaillonDevis *md;
@@ -68,19 +54,42 @@ ListeDevis insert(ListeDevis l, Devis d)
 	return md;
 }
 
-
-ListeDevis sortListeDevis(ListeDevis l)
+// Insere une liste dans le tableau de travaux
+Liste insertSucc(Liste l, char travaux[])
 {
-	//Tri fusion.
+	MaillonSucc *ms;
+	ms = (MaillonSucc *)malloc(sizeof(MaillonSucc));
+	if (ms == NULL)
+	{
+		printf("\033[0;31mErreur: \033[0mmalloc liste successeurs\n");
+		exit(1);
+	}
+	ms->nxt=l->nxt;
+	l->nxt=ms;
+	strcpy(ms->tache, travaux);
+	return l;
 }
 
+/*------------suppressions-------------*/
 
-Booleen emptyListe(ListeDevis l)
+// Supprime le premier maillon de la liste de devis
+ListeDevis delete(ListeDevis l)
 {
-	return l==NULL;
+	MaillonDevis *md;
+	if (l==NULL)
+	{
+		printf("\033[0;31mErreur: \033[0msuppression dans une liste vide\n");
+		exit(1);
+	}
+	md=l;
+	l=l->suiv;
+	free(md);
+	return l;
 }
 
+/*---------------calculs----------------*/
 
+// Calcule la longueur de la liste de devis
 int lenListeDevis(ListeDevis l)
 {
 	int len=0;
@@ -92,97 +101,50 @@ int lenListeDevis(ListeDevis l)
 	return len;
 }
 
-
-void displayListeDevis(ListeDevis l)
+// Calcule le nombre de precedences pour un travail donne
+int nombrePred(char travaux[], Precedence prec[], int tlog)
 {
-	while(l)
-	{
-		displayDevis(l->dev);
-		l=l->suiv;
-	}
+	int nbPred = 0, i;
+	for (i=0; i<tlog; i++)
+		if (strcmp(travaux, prec[i].travauxSucc)==0)
+			nbPred++;
+	return nbPred;
 }
 
+/*--------------informations------------*/
 
-//Offre
-
-Offre newOffre(char *travauxName)
+// Retourne une liste des successeurs pour un travail donne
+Liste lstSucc(char travaux[], Precedence prec[], int tlog)
 {
-	Offre o;
-	strcpy(o.travaux, travauxName);
-	o.ldevis=newListeDevis();
-	return o;
+	Liste succ = newListe();
+	int i;
+	for (i=0; i<tlog; i++)
+		if(strcmp(travaux, prec[i].travauxPrec)==0)
+			succ=insertSucc(succ, prec[i].travauxSucc);
+	return succ;
 }
 
+/*---------------affichages--------------*/
 
-Booleen emptyOffre(Offre *o)
+// Affiche les details d'un devis
+void displayDevis(Devis d)
 {
-	return emptyListe(o->ldevis);
+	printf("%s\t%s\t%d\t%d\t%d\n", d.nomE, d.adresse, d.capital, d.duree, d.prix);
 }
 
-
+// Affiche les details de l'offre et sa liste de devis
 void displayOffre(Offre *o)
 {
 	printf("Travaux: %s", o->travaux);
 	displayListeDevis(o->ldevis);
 }
 
-
-int rechTravaux(char *travauxName, Offre *tabTravaux[])
-{
-	int deb=0, end=tmaxTravaux-1, mid; //On utilise la taille max de travaux car travaux est un tableau constant, sa taille max est égale à sa taille logique.
-	while(deb<=end)
-	{
-		mid = (deb+end) /2;
-		if (strcmp(travauxName, tabTravaux[mid]->travaux)==0)
-			return mid;
-		if (strcmp(travauxName, tabTravaux[mid]->travaux) < 0)
-			end=mid-1;
-		else
-			deb=mid+1;
-	}
-	return -1;
-}
-
-void minTravaux(Offre *tabTravaux[])
-{
-	int i;
-	ListeDevis l, minl;
-	for (i=0; i<tmaxTravaux; i++)
-	{
-		l=tabTravaux[i]->ldevis;
-		minl=l;
-		while(l)
-		{
-			if(l->dev.prix < minl->dev.prix)
-			{
-				l=delete(minl);
-				minl=l;
-			}
-			else 
-				l=delete(l);
-			l=l->suiv;
-		}
-		displayOffre(tabTravaux[i]);
-	}
-
-}
-
-Liste newListe(void)
-{
-	return NULL;
-}
-
-Liste insertSucc(Liste l, char travaux[])
+// Affiche les details de la liste de devis
+void displayListeDevis(ListeDevis l)
 {
-	MaillonSucc *ms;
-	ms = (MaillonSucc *)malloc(sizeof(MaillonSucc));
-	if (ms == NULL)
+	while(l)
 	{
-		printf("\033[0;31mErreur: \033[0mmalloc liste successeurs\n");
-		exit(1);
+		displayDevis(l->dev);
+		l=l->suiv;
 	}
-	ms->nxt=l->nxt;
-	l->nxt=ms;
-	strcpy(ms->tache, travaux);
-	return l;
 }

tests/test_sort.c

@@ -0,0 +1,31 @@
+#include "../includes/main.h"
+
+//test tri fusion
+int	main(void)
+{
+	Offre offre1 = {"Travaux1", NULL};
+	offre1.ldevis = (ListeDevis)malloc(sizeof(struct maillonDevis));
+	offre1.ldevis->dev = (Devis){"Devis6", "Adresse1", 100, 5};
+	offre1.ldevis->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
+	offre1.ldevis->suiv->dev = (Devis){"Devis3", "Adresse3", 80, 3};
+	offre1.ldevis->suiv->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
+	offre1.ldevis->suiv->suiv->dev = (Devis){"Devis8", "Adresse2", 120, 7};
+	offre1.ldevis->suiv->suiv->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
+	offre1.ldevis->suiv->suiv->suiv->dev = (Devis){"Devis5", "Adresse5", 90, 4};
+	offre1.ldevis->suiv->suiv->suiv->suiv = (ListeDevis)malloc(sizeof(struct maillonDevis));
+	offre1.ldevis->suiv->suiv->suiv->suiv->dev = (Devis){"Devis2", "Adresse2", 110, 6};
+	offre1.ldevis->suiv->suiv->suiv->suiv->suiv = NULL;
+	int tlog = 5;
+
+	printf("Avant le tri : \n");
+	displayOffre(&offre1);
+
+	triFusionListeDevis(&offre1.ldevis, tlog);
+
+	printf("\nApres le tri : \n");
+	displayOffre(&offre1);
+
+	freeListeDevis(&offre1.ldevis);
+
+	return (0);
+}