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");
}
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;
}
void *pecore (void* arg){
pthread_t threadId = pthread_self();
printf("\x1B[37m[%s] : Je demande à être jugé !\n", (char*)arg);
enfiler(attenteJugement, threadId);
printf("\x1B[37m[%s] : J'attend mon jugement !\n", (char*)arg);
while(estDansLaFile(attenteJugement, threadId)==1);
etreJuge((char*)arg);
pthread_exit(NULL);
}
void empile_feuilles(File* F, Arbre A) {
if (A == NULL)
return;
if(A -> fils[0] == NULL)
*F = enfiler(*F, A);
else {
int i;
while(i < FILS_MAX && A -> fils[i] != NULL) {
empile_feuilles(F, A);
i++;
}
}
}
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 parcourLarg(tGraphe graphe, tNomSommet som)
{
int nb_sommets;
tNumeroSommet current;
//tNomSommet destination;
nb_sommets = grapheNbSommets(graphe);
numerosParcourus = (tNumeroSommet*)malloc(nb_sommets*sizeof(tNumeroSommet));
numerosEnfiles = (tNumeroSommet*)malloc(nb_sommets*sizeof(tNumeroSommet));
current = grapheChercheSommetParNom(graphe, som);
enfiler(current);
while(!fileEstVide()){
int i, nb_successeurs;
tNomSommet sommet;
current = numerosEnfiles[enfilesIndex++];
grapheRecupNomSommet (graphe, current, sommet);
printf(" %s ",sommet);
if (grapheEstOriente(graphe))
{
nb_successeurs = grapheNbSuccesseursSommet(graphe,current);
for ( i = 0 ; i < nb_successeurs ; i++ ){
enfiler(grapheSuccesseurSommetNumero(graphe,current,i));
}
}
else
{
nb_successeurs = grapheNbVoisinsSommet(graphe,current);
for ( i = 0 ; i < nb_successeurs ; i++ ){
enfiler(grapheVoisinSommetNumero(graphe,current,i));
}
}
}
printf("\n");
free(numerosParcourus);
free(numerosEnfiles);
}
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 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);
}
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;
}
File algo_fileACM(Sommet * tab_sommet, Arc * tab_arc,
int len_tab_sommet, int len_tab_arc,
int num_depart, float *cout)
{
File fileACM = NULL;
Liste C = NULL;
Liste liste_sommet_atteint = NULL;
Sommet d = tab_sommet[num_depart];
/*
DEBUT ALGO PRIM
*/
Sommet *smt;
for (smt = tab_sommet; smt < tab_sommet + len_tab_sommet; smt++) {
smt->PPC = FLT_MAX;
smt->arrive_par = NULL;
}
d.PPC = 0;
d.arrive_par = NULL;
C = ajout_tri(&d, C);
liste_sommet_atteint = ajouter_queue(&d, liste_sommet_atteint, sizeof(Sommet));
while (!est_vide_liste(C)) {
Sommet sommet_ppc_min;
Liste liste_sommet_adjacent = NULL;
Liste liste_arc_sortant = NULL;
Arc *a;
Liste ll;
/*on récupère le sommet de plus petit PPC et son coût */
/*Comme la liste est triée, c'est le premier élément de C */
sommet_ppc_min = *(Sommet *) C->val;
/*supprimer j de C */
C = supprimer_tete(C);
/*si j n'est pas d */
if (sommet_ppc_min.numero != d.numero) {
*cout += sommet_ppc_min.PPC;
fileACM = enfiler(fileACM, sommet_ppc_min.arrive_par, sizeof(Arc));
liste_sommet_atteint = ajouter_queue(&sommet_ppc_min, liste_sommet_atteint, sizeof(Sommet));
}
/* on récupère les adjacents */
for (a = tab_arc; a < tab_arc + len_tab_arc; a++) {
if (a->sommet_depart == sommet_ppc_min.numero) {
liste_sommet_adjacent = ajouter_queue(&tab_sommet[a->sommet_arrive], liste_sommet_adjacent, sizeof(Sommet));
liste_arc_sortant = ajouter_queue(a, liste_arc_sortant, sizeof(Arc));
}
}
sommet_ppc_min.voisins = liste_arc_sortant;
// printf("Sommet: %s\n", sommet_ppc_min.nom);
for (ll = liste_arc_sortant; !est_vide_liste(ll); ll = ll->suiv) {
a = (Arc *) ll->val;
if ((tab_sommet[a->sommet_arrive]).PPC > a->cout) {
tab_sommet[a->sommet_arrive].PPC = a->cout;
tab_sommet[a->sommet_arrive].arrive_par = a;
if (recherche_elt_liste(liste_sommet_atteint, &tab_sommet[a->sommet_arrive]) != 1) {
if (recherche_elt_liste(C, &tab_sommet[a->sommet_arrive]) != 1) {
C = ajout_tri(&tab_sommet[a->sommet_arrive], C);
} else {
Liste L = C;
Liste l;
C = NULL;
for (l = L; !est_vide_liste(l); l = l->suiv ) {
C = ajout_tri(&tab_sommet[((Sommet*) l->val)->numero], C);
}
}
}
}
}
}
printf("Cout de l'acm: %f\n", *cout);
/* FIN ALGO PRIM */
return fileACM;
}
