void rendreJustice(){
printf("\x1B[32m[Arthur] : je rends la justice !\n");
sem_wait(&justiceRendue);
defiler(attenteJugement);
sleep(rand()%2);
defiler(attenteJugement);
sleep(rand()%2);
defiler(attenteJugement);
sleep(rand()%2);
printf("\x1B[32m[Arthur] : la justice est rendue!\n");
sem_post(&justiceRendue);
}
int main()
{
File *file = malloc(sizeof(*file));
enfiler(file, 4);
enfiler(file, 8);
enfiler(file, 15);
enfiler(file, 16);
enfiler(file, 23);
enfiler(file, 42);
afficherFile(file);
printf("\nJe defile %d\n", defiler(file));
printf("\nJe defile %d\n", defiler(file));
afficherFile(file);
return 0;
}
void
detruireFile (File ** f)
{
while (*f != NULL)
{
defiler (f);
}
}
int main(int argc, char *argv[])
{
file * f1 = creer_file();
printf("Création file 1\n");
afficher_file(f1);
enfiler(f1, 50);
enfiler(f1, 25);
enfiler(f1, 2);
enfiler(f1, 7);
printf("Affichage file 1\n");
afficher_file(f1);
printf("Défile file 1\n");
defiler(f1);
afficher_file(f1);
enfiler(f1, 7);
printf("Enfile file 1\n");
afficher_file(f1);
file * f2 = creer_file();
enfiler(f2, 3);
enfiler(f2, 4);
enfiler(f2, 5);
printf("Création file 2\n");
afficher_file(f2);
printf("Concaténation file 1 et 2\n");
concatener_files(f1, f2);
afficher_file(f1);
defiler(f1);
defiler(f1);
defiler(f1);
defiler(f1);
defiler(f1);
defiler(f1);
printf("Défiler file 1\n");
afficher_file(f1);
printf("File 1 est vide : ");
printf("%d\n", file_estVide(f2));
destruction(f2);
destruction(f1);
return 0;
}
int main(void)
{
File *myFile = initialiser();
remplirFile(myFile, 4);
remplirFile(myFile, 8);
remplirFile(myFile, 15);
remplirFile(myFile, 16);
remplirFile(myFile, 32);
remplirFile(myFile, 42);
afficherFile(myFile);
defiler(myFile);
defiler(myFile);
afficherFile(myFile);
return 0;
}
void file_detruire ( file * f )
{
if ( NULL == f )
return;
while( !file_vide(f) )
defiler(f);
free( ( *(File**)f ) );
free( f );
}
int bicolore(graphe g){
char* coule = (char*)calloc(g.nbsom,sizeof(char*));
file* liste = creer_file();
int ori, nbSommet=0,courant,nbS=g.nbsom,i,j;
ori =0;
for(i=0;i<nbS;i++){
coule[i]='N';
}
enfiler(liste,ori);
nbSommet++;
coule[ori] ='B';
while(nbSommet<nbS){
while(!(file_estVide(liste))){
courant = defiler(liste);
printf("Sommet %d, couleur : %c\n", courant, coule[courant]);
for(i=0;i<nbS;i++){
if(g.matrice[courant][i]==1){
if(coule[i]!=coule[courant]){
if(coule[i]=='N'){
if(coule[courant]=='B'){
coule[i]='J';
}else{
coule[i]='B';
}
enfiler(liste,i);
nbSommet++;
}
}else{
return 0;
}
}
}
coule[courant]=2;
}
if(nbSommet!=nbS){
while(coule[j]!=0){
j++;
}
enfiler(liste,j);
nbSommet++;
coule[j]='B';
}
}
free(coule);
free(liste);
return 1;
}
int pLargeur(graphe g){
int nbS=g.nbsom, i,ori=0, nbSommet, courant, nscc, booleen =1, ncc=0,j=0;
file* liste = creer_file();
int* coule= (int*)calloc(nbS,sizeof(int*));
ori =0;
enfiler(liste,ori);
nbSommet = 0;
nbSommet++;
coule[ori] =1;
while(nbSommet<nbS){
ncc++;
nscc=0;
while(!(file_estVide(liste))){
courant = defiler(liste);
printf("Sommet %d\n", courant);
for(i=0;i<nbS;i++){
if(g.matrice[courant][i]==1){
if(coule[i]==0){
coule[i]=1;
enfiler(liste,i);
nbSommet++;
}
}
}
coule[courant]=2;
nscc++;
}
printf("La %deme composante connexe contient %d sommet(s). Nous avons actuellement %d/%d sommets\n",ncc, nscc, nbSommet,nbS);
if(nscc != nbS){
booleen = 0;
if(nbSommet!=nbS){
while(coule[j]!=0){
j++;
}
enfiler(liste,j);
nbSommet++;
}
if(nbS == nbSommet){
printf("La %deme composante connexe contient %d sommet(s). Nous avons actuellement %d/%d sommets\n",ncc+1, 1, nbSommet,nbS);
}
}
}
free(coule);
free(liste);
return booleen;
}
/* Affiche l'arbre en largeur */
void parcours_largeur(NOEUD * rac)
{
file * f = creer_file();
enfiler(f, rac);
NOEUD * p;
while (! file_estVide(f))
{
p = defiler(f);
printf("%d ", p->valeur);
if (p->gauche) enfiler(f, p->gauche);
if (p->droit) enfiler(f, p->droit);
}
printf("\n");
}
void inversion_pile(lifo_t * p)
{
/*variables locales*/
fifo_t * f = NULL; /*file*/
type_t tmp; /*valeurs a afficher*/
int err; /*erreur*/
/*initialisation*/
f = (fifo_t *)malloc(sizeof(fifo_t));
err = init_fifo(f,p->t_max);
if (! err)
{
printf("Pile a inverser :\n");
afficher_lifo(p);
/*parcours de la pile*/
while (!lifo_vide(p))
{
tmp = depiler(p); /*passage des valeurs*/
enfiler(f,tmp);
}
printf("Etat de la file :\n");
afficher_fifo(f);
while (! fifo_vide(f))
{
tmp = defiler(f); /*passage des valeurs*/
empiler(p,tmp);
}
/*liberation de la file*/
free_fifo(f);
}
printf("Pile inversee :\n");
afficher_lifo(p);
}
Arbre algo_arbreACM(File fileACM, Sommet * tab_sommet, int num_depart)
{
Arbre arbreACM = NULL;
Arc* ptr_arc = NULL;
arbreACM = malloc(sizeof(*arbreACM));
if (arbreACM == NULL)
return NULL;
arbreACM->sommet = &tab_sommet[num_depart];
tab_sommet[num_depart].noeudArbreACM = arbreACM;
while (!est_vide_file(fileACM)) {
ptr_arc = (Arc *) defiler(&fileACM);
ajouter_arbre(ptr_arc, tab_sommet);
}
return arbreACM;
}
void completer(ACListe acListe){
initFile();
int i, suppleant;
List l = acListe->trie->transition[0];
List tmp = NULL;
// Creation d'une liste qui contient toute l'alphabet avec un target qui egale à 0
List tmpListTransition0 = NULL ;
for(i = 0; i < alphabet ; i++){
addListeNode(&tmpListTransition0, (char) i, 0);
}
while(l != NULL){
enfiler(l->targetNode);
acListe->suppleant[l->targetNode] = 0;
tmp = findNodeByLettre( l, l->letter);
tmp->targetNode = l->targetNode;
l = l->next;
}
l = tmpListTransition0;
while(!isEmpty()){
int r = defiler();
l = acListe->trie->transition[r];
while(l != NULL){
enfiler(l->targetNode);
suppleant = acListe->suppleant[r];
while(findNodeByLettre(acListe->trie->transition[suppleant], l->letter) == NULL){
suppleant = acListe->suppleant[suppleant];
}
acListe->suppleant[l->targetNode] = findNodeByLettre(acListe->trie->transition[suppleant], l->letter)->targetNode;
acListe->trie->finite[l->targetNode] += acListe->trie->finite[acListe->suppleant[l->targetNode]];
l = l->next;
}
}
}
void parcourirTouteau(s_grille* g, int x,int y)
{
liste_element *file = (liste_element*)malloc(sizeof(liste_element));// liste finale des noeuds de la file d'attente
element *s = (element*)malloc(sizeof(element));
element *ps = (element*)malloc(sizeof(element));
element*p = (element*)malloc(sizeof(element)); // noeuds du chemin
int i,j;
int ii,jj;
int compteur=500;/// LIMITE pour le dessalement
ps=&g->elem[x][y];
//on met toutes les marques à zero
for(i=0; i<L; i++)
{
for(j=0; j<H; j++)
{
if(g->elem[i][j].etatsssol==1)
g->elem[i][j].marque_eau=0;
}
}
// on alloue la liste, on enfile le premier noeud dans la liste
file->queue=file->tete=NULL;
file->taille=0;
// enfiler(g,file, ps);
////////////////////////////////////////////////////////////////////////////////////////////
element* nouveau=(element*)malloc(sizeof(element));
nouveau->next=NULL;
nouveau->i=ps->i;
nouveau->j=ps->j;
if (file->taille==0)
file->tete = file->queue = nouveau ;
else
{
file->queue->next = nouveau ;
file->queue = nouveau ;
}
file->taille++ ;
/////////////////////////////////////////////////////////////////////////////////////////////
// si le noeud de départ ps n'a pas de voisin, retourner la liste qui ne contient que ce noeud
/* if (g->[ps->i][ps->j]==NULL)
return ;
*/
// marquer le noeud de départ ps
g->elem[ps->i][ps->j].marque_eau = 1;
g->elem[ps->i][ps->j].alimeau= 1;//on dit que la canalisation est alimentée en eau
// tant que la file d'attente n'est pas vide et que le noeud out n'est pas atteint
while (!estVide(file) && compteur>0)
{
//printf("passage\n");
s = defiler(file); // défiler le premier noeud de la liste
// printf("defiler: %d::%d\n",s->i,s->j);
// si le noeud défilé arrive au noeud de sortie out (s'il existe), on sort
//printf("taille:%d\n",g->file_elemeau[s->i][s->j].taille);
// le noeud défilé n'est pas out, enfiler ses voisins non marqués
if (&g->elem[s->i][s->j] != NULL && (g->file_elemeau[s->i][s->j].taille!=0))
{
//printf("passage\n");
for(p = g->file_elemeau[s->i][s->j].tete ; p != NULL ; p = p->next)
{
if (g->elem[p->i][p->j].marque_eau==0)
{
// printf("coucou%d::%d",p->i,p->j);
////////////////////////////////////////////////////////////////////////////////////////////////////////
element* nouveau=(element*)malloc(sizeof(element));
nouveau->next=NULL;
nouveau->i=p->i;
nouveau->j=p->j;
if (file->taille==0)
file->tete = file->queue = nouveau ;
else
{
file->queue->next = nouveau ;
file->queue = nouveau ;
}
file->taille++ ; // empiler le noeud voisin dans la liste
/////////////////////////////////////////////////////////////////////////////////////////////////
///VERIFICATION DES MAISONS AUX ALENTOURS DE LA CASE D'EAU
if(compteur>0)
{
int temp=0;
for(ii=-5; ii<6; ii++)
{
for(jj=-temp; jj<temp+1; jj++)
{
if((g->elem[p->i+jj][p->j+ii].etatsol==3)&&(p->i+jj<L)&&(p->j+ii<H)&&(p->i+jj>0)&&(p->j+ii>0)&&(g->elem[p->i+jj][p->j+ii].alimeau==0))
{
g->elem[p->i+jj][p->j+ii].alimeau=1;
compteur=compteur-g->elem[p->i+jj][p->j+ii].habitant; /// On décrémente le compteur
printf("alim_maison eau");
}
}
if(ii<0) temp++;
else temp--;
}
}
/* for(ii=0; ii<5; ii++)
{
if((g->elem[p->i+ii][p->j].etatsol==3)&&(p->i+ii<40)&&(g->elem[p->i+ii][p->j].alimeau==0))//3 conditions : La case est une maison, blindage i
{
printf("alim_maison");
//Et la maison n'est pas encore alimentée
g->elem[p->i+ii][p->j].alimeau=1;/// La maison est connectée à la canalisation
compteur=compteur-g->elem[p->i+ii][p->j].habitant; /// On décrémente le compteur
}
if((g->elem[p->i-ii][p->j].etatsol==3)&&(i-ii>0)&&(g->elem[p->i-ii][p->j].alimeau==0))
{
printf("alim_maison");
g->elem[p->i-ii][p->j].alimeau=1;
compteur=compteur-g->elem[p->i-ii][p->j].habitant; /// On décrémente le compteur
}
if((g->elem[p->i][p->j-ii].etatsol==3)&&(p->j-ii>0)&&(g->elem[p->i][p->j-ii].alimeau==0))
{
printf("alim_maison");
g->elem[p->i][p->j-ii].alimeau=1;
compteur=compteur-g->elem[p->i][p->j-ii].habitant; /// On décrémente le compteur
}
if((g->elem[p->i][p->j+ii].etatsol==3)&&(p->j+ii<40)&&(g->elem[p->i][p->j+ii].alimeau==0))
{
printf("alim_maison");
g->elem[p->i][p->j+ii].alimeau=1;
compteur=compteur-g->elem[p->i][p->j+ii].habitant; /// On décrémente le compteur
}
}*/
/// FIN de vérification des maisons autour de la case
g->elem[p->i][p->j].marque_eau = 1; // marquer le noeud du noeud voisin
g->elem[p->i][p->j].alimeau= 1;//on dit que la canalisation est alimentée en eau
}
// printf("coucou\n");
// soprintf("voisinsuiv:%d::%d\n",p->next->i,p->next->j);
}
}
}
}
file * trier_monotonie (file * fileSource)
{
unsigned i = 0,
nbMono = 1, /* on aura toujours au moins une monotonie */
nbMonotonies = 1; /* */
int comp;
int *nbelem1,
*nbelem2;
file *f1 = (file *) malloc( sizeof( file* ) ),
*f2 = (file *) malloc( sizeof( file* ) );
file_creer(f1, &string_copier, &string_liberer);
file_creer(f2, &string_copier, &string_liberer);
/* compte le nb de monotonies */
while ( i < file_taille( fileSource )-1 )
{
comp = string_file_comparer_elements( fileSource, fileSource, (unsigned)i, (unsigned)i+1, &strcmp );
if ( comp > 0 )
{
nbMono++;
}
i++;
}
if (nbMono == 1)
{
return fileSource;
}
if ( nbMono % 2 )
{
nbelem1 = malloc( (( nbMono / 2 ) + 1) * sizeof( int ) );
nbelem2 = malloc( (( nbMono / 2 ) + 1) * sizeof( int ) );
}
else
{
nbelem1 = malloc( ( nbMono / 2 ) * sizeof( int ) );
nbelem2 = malloc( ( nbMono / 2 ) * sizeof( int ) );
}
do /* Processus de tri */
{
i = 0;
while( i < nbMono - 1 )
{
nbelem1[i] = 0;
nbelem2[i] = 0;
i++;
}
nbMono = 1;
nbMonotonies = 1;
do /* Séparation en deux files */
{
comp = string_file_comparer_elements( fileSource, fileSource, (unsigned)0, (unsigned)1, &strcmp );
if ( nbMono % 2 )
{
enfiler( f2, tete( fileSource ) );
nbelem2[nbMonotonies-1]++;
defiler( fileSource );
}
else
{
enfiler( f1, tete( fileSource ) );
nbelem1[nbMonotonies-1]++;
defiler( fileSource );
}
if ( comp > 0 )
{
nbMono++;
if ( nbMono % 2 )
nbMonotonies++;
}
} while ( file_taille( fileSource ) > 1 );
if ( nbMono % 2 )
{
enfiler( f2, tete( fileSource ) );
nbelem2[nbMonotonies-1]++;
defiler( fileSource );
}
else
{
enfiler( f1, tete( fileSource ) );
nbelem1[nbMonotonies-1]++;
defiler( fileSource );
}
nbMono = 0;
if (nbMonotonies != 1)
{
while( !file_vide( f1 ) || !file_vide( f2 ) ) /* tant qu'il existe des elements dans une des deux files... */
{
if( ! nbelem1[nbMono] && ! nbelem2[nbMono] ) /* Si les deux files sont vides */
{
nbMono++; /* passe a la monotonie suivante */
}
else /* sinon */
{
if ( !nbelem1[nbMono] ) /* si la monotonie actuelle dans f1 est vide et l'autre dans f2 contient des elements */
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMono]--;
}
else if ( !nbelem2[nbMono] ) /* sinon si la monotonie actuelle dans f2 est vide et l'autre dans f1 contient des elements */
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMono]--;
}
else /* sinon les deux monotonies contiennent des elements : on peut donc les comparer */
{
comp = string_file_comparer_elements( f1, f2, (unsigned)0, (unsigned)0, &strcmp ) ;
if ( comp <= 0 )
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMono]--;
}
else
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMono]--;
}
}
}
}
}
else /* On a fini : */
{
while( !file_vide( f1 ) || !file_vide( f2 ) ) /* Tant que f1 et f2 ne sont pas vide */
{
/* on insere la plus petite valeur */
if ( !nbelem1[nbMonotonies-1] ) /* si la monotonie actuelle dans f1 est vide et l'autre dans f2 contient des elements */
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMonotonies-1]--;
}
else if ( !nbelem2[nbMonotonies-1] ) /* sinon si la monotonie actuelle dans f2 est vide et l'autre dans f1 contient des elements */
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMonotonies-1]--;
}
else
{
comp = string_file_comparer_elements( f1, f2, (unsigned)0, (unsigned)0, &strcmp ) ;
if ( comp <= 0 )
{
enfiler( fileSource, tete( f1 ) );
defiler( f1 );
nbelem1[nbMonotonies-1]--;
}
else
{
enfiler( fileSource, tete( f2 ) );
defiler( f2 );
nbelem2[nbMonotonies-1]--;
}
}
}
}
/* compte le nb de monotonies */
i = 0;
nbMono = 1;
while ( i < file_taille( fileSource ) - 1 )
{
comp = string_file_comparer_elements( fileSource, fileSource, (unsigned)i, (unsigned)i+1, &strcmp );
if ( comp > 0 )
{
nbMono++;
}
i++;
}
} while (nbMono != 1);
free(nbelem1);
free(nbelem2);
return fileSource;
}
void destruction(file * f)
{
while (defiler(f) >= 0);
free(f);
}
