163 lines
4.2 KiB
Markdown
163 lines
4.2 KiB
Markdown
TP Graphes 1 : Codage de graphes
|
|
============
|
|
|
|
- - - - -
|
|
Exercice 1 : Matrice d'adjacence
|
|
----------
|
|
Un graphe sera représenté ici par une structure contenant un entier (son ordre), un entier booléen (orienté ou non), et son ensemble d'arêtes, représenté par sa matrice d'adjacence :
|
|
|
|
```
|
|
struct graphe{
|
|
int ordre; // l'ordre du graphe
|
|
int** adj; // la matrice d'adjacence, donnée par un double tableau dynamique
|
|
int oriente; // vaut 0 si le graphe est non orienté, 1 sinon
|
|
};
|
|
|
|
typedef struct graphe graphe;
|
|
```
|
|
|
|
**Question :**
|
|
Ecrire une fonction permettant de créer un graphe vide à partir de son ordre et de son orientation :
|
|
```
|
|
graphe creergraphe(int ord,int or);
|
|
```
|
|
La fonction devra entre autres réserver de la mémoire pour la matrice d'adjacence.
|
|
|
|
**Question :**
|
|
Ecrire une fonction prenant un graphe et deux sommets, et ajoutant une arête entre ces deux sommets :
|
|
```
|
|
void ajoutArete(graphe g,int v,int w){
|
|
```
|
|
|
|
**Question :**
|
|
Si le graphe est non orienté, toute arête de v vers w ajoute également une arête de w vers v.
|
|
Modifiez la fonction précédente pour en prendre compte.
|
|
|
|
**Question :**
|
|
Créez dans le main le graphe des frontières de la France (on ne considérera pas les micro-états).
|
|
|
|
Aide : Vous pouvez utiliser la fonction suivante pour afficher votre graph. Elle utilise la bibliothèque graphique de l'IUT.
|
|
Il faut donc ajouter ``-lgraph`` lors de la compilation.
|
|
```
|
|
void visuelGraphe(graphe g){
|
|
int taille=1000;
|
|
int origine=taille/2;
|
|
int distance=4*origine/5;
|
|
int tailleVert=taille/20;
|
|
InitialiserGraphique();
|
|
CreerFenetre(10,10,taille,taille);
|
|
|
|
int i,j;
|
|
int x,y;
|
|
char* nV=malloc(2);
|
|
*nV='0';
|
|
*(nV+1)='\0';
|
|
int* cX=calloc(g.ordre,sizeof(int));
|
|
int* cY=calloc(g.ordre,sizeof(int));
|
|
for(i=0;i<g.ordre;i++){
|
|
x=(int) origine+distance*cos(2*M_PI*i/g.ordre);
|
|
y=(int) origine+distance*sin(2*M_PI*i/g.ordre);
|
|
cX[i]=x+tailleVert/2;
|
|
cY[i]=y+tailleVert/2;
|
|
RemplirArc(x,y,tailleVert,tailleVert,0,360);
|
|
EcrireTexte(x,y,nV,2);
|
|
(*nV)++;
|
|
|
|
}
|
|
|
|
for(i=0;i<g.ordre;i++){
|
|
for(j=0;j<g.ordre;j++){
|
|
if(g.adj[i][j]!=0){
|
|
DessinerSegment(cX[i],cY[i],cX[j],cY[j]);
|
|
}
|
|
}
|
|
}
|
|
Touche();
|
|
FermerGraphique();
|
|
|
|
}
|
|
```
|
|
|
|
- - - - -
|
|
Exercice 2 : Voisinage
|
|
----------
|
|
|
|
**Question :**
|
|
Ecrire une fonction permettant de d'afficher les voisins d'un sommet dans un graphe non orienté.
|
|
Testez votre fonction sur le graphe créé au premier exercice.
|
|
|
|
**Question :**
|
|
Modifiez votre fonction pour afficher les voisins sortants et les voisins entrants si le graphe est orienté.
|
|
|
|
**Question :**
|
|
Ecrire une fonction comptant le nombre de voisins d'un sommet dans un graphe, en gérant les cas orienté ou non orienté.
|
|
|
|
**Question :**
|
|
Vérifiez sur le graphe créé la propriété du cours :
|
|
|
|
La somme du nombre de voisins de tous les états est égal au nombre d'arêtes x 2.
|
|
|
|
|
|
- - - - -
|
|
Exercice 3 : Listes
|
|
----------
|
|
Il est possible de coder l'ensemble des voisins d'un sommet par une liste chaînée.
|
|
Pour cela, on utilise un codage des listes chaînées :
|
|
```
|
|
struct mail{
|
|
int valeur;
|
|
struct mail *suivant;
|
|
};
|
|
```
|
|
Ainsi que des fonctions les utilisant :
|
|
```
|
|
int tailleM(maillon *m){ //Renvoie la taille d'une liste
|
|
int res=0;
|
|
while(m!=NULL)){
|
|
res++;
|
|
m=m->suivant;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void affiche(maillon *m){ //Affiche le contenu d'une liste
|
|
if(m==NULL){
|
|
printf("\n");
|
|
}else{
|
|
printf("%d, ",m->valeur);
|
|
affiche(m->suivant);
|
|
}
|
|
}
|
|
|
|
|
|
maillon* ajouterDebut(maillon* m,int val){ //Renvoie la liste enrichie de val
|
|
maillon* res=malloc(sizeof(maillon));
|
|
res->valeur=val;
|
|
res->suivant=m;
|
|
return res;
|
|
}
|
|
|
|
int estDans(maillon* m,int val){ //Renvoie 0 si val n'est pas dans la liste, 1 sinon
|
|
if(m==NULL){
|
|
return 0;
|
|
}
|
|
if(m->valeur==val){
|
|
return 1;
|
|
}
|
|
return estDans(m->suivant,val);
|
|
}
|
|
```
|
|
A partir de ces listes, on peut donc définir un graphe comme suit :
|
|
```
|
|
struct graphe{
|
|
int ordre;
|
|
maillon** voisins;
|
|
int oriente;
|
|
};
|
|
```
|
|
Où voisins est un tableau de listes chaînées.
|
|
|
|
|
|
**Question :**
|
|
Recréez les fonctions codées dans les exercices précédents en les adaptant à cet encodage de graphes.
|
|
Normalement, vous devriez pouvoir utiliser la même fonction `main` pour tester votre code. |