Esempio n. 1
0
void grapheAjouteArc(tGraphe graphe, tArc arc) {
  tNumeroSommet orig, dest;
  tNomSommet nom_orig, nom_dest;
  
  orig = arc.orig;
  dest = arc.dest;

  /* On teste si l'arc existe déjà ou pas */
  if (grapheExisteArcEntre(graphe, orig, dest)) {
    grapheRecupNomSommet(graphe, orig, nom_orig);
    grapheRecupNomSommet(graphe, dest, nom_dest);
    halt("Un arc existe deja  entre les sommets %s (numero %d) "
	 "et %s (numero %d)\n",
	 nom_orig, orig, nom_dest, dest);
  }


  /* la matrice d'adjacence */
  graphe->matriceAdjacence[orig][dest] = arc.val;
  if (!grapheEstOriente(graphe)) {
    graphe->matriceAdjacence[dest][orig] = arc.val;
  }

  if (grapheEstOriente(graphe)) {
    /* ajout dans les successeurs */
    tableauEntiersAjoute(& (graphe->tableSuccesseurs[orig]), dest);
    /* ajout dans les prédécesseurs */
    tableauEntiersAjoute(& (graphe->tablePredecesseurs[dest]), orig);
  } 

  /* Même si l'arbre est orienté, on remplit la table des voisins.
     Toutefois, si l'arc est orienté, on vérifie que l'arc
     inverse n'existe pas déjà , car dans ce cas les voisins sont
     déjà placés. */
  
  if ( ! ( grapheEstOriente(graphe) && 
	   grapheExisteArcEntre(graphe,dest,orig) ) ) {
      tableauEntiersAjoute(& (graphe->tableVoisins[orig]), dest);
      /* si l'arc va du sommet vers lui même, on n'ajoute pas de voisin */
      if (orig!=dest)
	tableauEntiersAjoute(& (graphe->tableVoisins[dest]), orig);
    }
  /* Mise à jour de la table des arcs */
  tableauArcsAjoute(& (graphe->tableArcs), arc);
}
Esempio n. 2
0
void graphe2visu(tGraphe graphe, char *outfile) {
				FILE *fic;
				char commande[80];
				char dotfile[80]; /* le fichier dot pour creer le ps */
				int ret,nbsommets;

				nbsommets = grapheNbSommets(graphe);
				
				int i,j;
				tNomSommet nomSommet;
				tNomSommet nomVoisin;

				/* on va creer un fichier pour graphviz, dans le fichier "outfile".dot */

				strcpy(dotfile, outfile);
				strcat(dotfile, ".dot");

				fic = fopen(dotfile, "w");

				if (fic==NULL)
				halt ("Ouverture du fichier %s en ecriture impossible\n", dotfile);
				

				fprintf(fic, "graph {\n");
				/*tester tous les sommets*/
					for (i=0; i<nbsommets; i++){
					/*nbvoisins =grapheNbVoisinsSommet(graphe,i); */
					/*tester les voisins du sommet*/
						for(j=0; j <nbsommets;j++){
							if (grapheExisteArcEntre(graphe,i,j)){
								
								grapheRecupNomSommet(graphe, i, nomSommet);

								grapheRecupNomSommet(graphe,j, nomVoisin);
								
								fprintf(fic, "  %s -- %s\n", nomSommet, nomVoisin);
							}
				
						}	
			    	}/*mettre ; ?????????,*/
				fprintf(fic, "}");
				fclose(fic);
				
				sprintf(commande, "dot -Tps %s -o %s", dotfile, outfile);

				ret = system(commande);

				if (WEXITSTATUS(ret))
				
				halt("La commande suivante a echouee\n%s\n", commande);
}
Esempio n. 3
0
tValeurArc grapheRecupValeurArc(tGraphe graphe,
			 tNumeroSommet depart,
			 tNumeroSommet arrivee){

  if ( (depart<0) || (depart>=graphe->nbSommets) ) {
    halt("Numero de sommet d'origine incorrect %d\n", depart);
  }

  if ( (arrivee<0) || (arrivee>=graphe->nbSommets) ) {
    halt("Numero de sommet de destination incorrect %d\n", arrivee);
  }

  if ( !grapheExisteArcEntre(graphe, depart, arrivee) ) {
    halt("Il n'y pas d'arc entre le sommet %d et le sommet arrivee %d",
	 depart, arrivee);
  }
  return graphe->matriceAdjacence[depart][arrivee];
}
Esempio n. 4
0
/* Affichage */
void grapheAffiche(tGraphe graphe) {
  tNomSommet nom;
  tNumeroSommet i, j, successeur, predecesseur;
  tValeurArc val;
  tArc arc;
  /* Affiche la liste des sommets et leur nom */
  printf("Type de l'arbre : ");
  if (grapheEstOriente(graphe))  printf("orientee"); 
  else printf("non orientee");
  printf("\n\n");

  printf("Nombre de sommets : %d\n\n", grapheNbSommets(graphe));

  printf("Liste des sommets avec leurs numeros:\n");
  for(i=0; i < grapheNbSommets(graphe);i++) {
    grapheRecupNomSommet(graphe, i, nom);
    printf("- %d : %s\n", i, nom);
  }
  printf("\n");

  /* Matrice d'adjacence */
  printf("Matrice d'adjacence :\n");
  printf("%2s", "");
  for(i=0; i < grapheNbSommets(graphe);i++) {
    printf("%7d", i);
  }
  printf("\n");
  
  for(i=0; i < grapheNbSommets(graphe);i++) {
    printf("%3d ", i);
    for(j=0; j < grapheNbSommets(graphe);j++) {
      if (grapheExisteArcEntre(graphe,i,j)) {
	val = grapheRecupValeurArc(graphe,i,j);
	printf("%6.2f ", val);}
      else
	printf("       ");
    }
    printf("\n");
  }
  printf("\n");

  /* Affiche les voisins, successeurs, prédecesseurs */
  if (grapheEstOriente(graphe)) {
    /* affichage des successeurs */
    printf("Liste des successeurs :\n");
    for(i=0; i < grapheNbSommets(graphe);i++) {
      grapheRecupNomSommet(graphe, i, nom);
      printf("%s : ", nom);
      for(j=0; j<grapheNbSuccesseursSommet(graphe, i); j++) {
	successeur = grapheSuccesseurSommetNumero(graphe, i, j);
	grapheRecupNomSommet(graphe, successeur, nom);
	printf("%s=%.2f ", nom, 
	       grapheRecupValeurArc(graphe, i, successeur));
      }
      printf("\n");
    }
    /* affichage des prédécesseurs */
    printf("\nListe des predecesseurs :\n");
    for(i=0; i < grapheNbSommets(graphe);i++) {
      grapheRecupNomSommet(graphe, i, nom);
      printf("%s : ", nom);
      for(j=0; j<grapheNbPredecesseursSommet(graphe, i); j++) {
	predecesseur = graphePredecesseurSommetNumero(graphe, i, j);
	grapheRecupNomSommet(graphe, predecesseur, nom);
	printf("%s=%.2f ", nom, 
	       grapheRecupValeurArc(graphe, predecesseur, i));
      }
      printf("\n");
    }

  } else {
    /* le graphe n'est pas orienté */
    printf("Liste des voisins :\n");
    for(i=0; i < grapheNbSommets(graphe);i++) {
      grapheRecupNomSommet(graphe, i, nom);
      printf("%s : ", nom);
      for(j=0; j<grapheNbVoisinsSommet(graphe, i); j++) {
	successeur = grapheVoisinSommetNumero(graphe, i, j);
	grapheRecupNomSommet(graphe, successeur, nom);
	printf("%s=%.2f ", nom, 
	       grapheRecupValeurArc(graphe, i, successeur));
      }
      printf("\n");
    }
  }
  printf("\n");
  
/* Affiche la liste des arcs */
  printf("Liste des arcs :\n");
  for(i=0; i < grapheNbArcs(graphe); i++) {
    arc = grapheRecupArcNumero(graphe, i);
    grapheRecupNomSommet(graphe, arc.orig, nom);
    printf("%s", nom);
    if (grapheEstOriente(graphe))
      printf(" -> ");
    else
      printf(" -- ");
    grapheRecupNomSommet(graphe, arc.dest, nom);
    printf("%s ",nom);
    printf("  = %.2f\n", arc.val);
  }
  
}