Le TP est prévu pour être fait en utilisant le codage des graphes à l'aide de matrices d'adjacence.
Pour plus de clarté, vous pouvez utiliser un nouveau fichier, en copiant les structures et fonctions nécessaires depuis les TPs précédants.
- - - - -
Exercice 1 : Parcours en largeur
----------
Pour cet exercice, vous aurez besoin de file FIFO, dont voici la structure et les primitives :
```
struct file{
int data;
struct file* succ;
};
typedef struct file fifo;
void enqueue(fifo **fi,int v){
fifo *nf=malloc(sizeof(fifo));
nf->data=v;
nf->succ=*fi;
(*fi)=nf;
}
int dequeue(fifo **fi){
fifo *lect=*fi;
if(lect->succ==NULL){
int res=lect->data;
*fi=NULL;
return res;
}
while(lect->succ->succ!=NULL){
lect=lect->succ;
}
int res=lect->succ->data;
fifo *temp=lect->succ;
lect->succ=NULL;
free(temp);
return res;
}
int empty(fifo *fi){
return fi==NULL;
}
```
On rappelle que pour une variable `fifo *fi`, on empile 3 en faisant `enqueue(&fi,3)` et on défile (et on stocke dans une variable x) en faisant `x=dequeue(&fi)`.
Tester sur un graphe (au hasard celui des frontières). Cela correspond-t-il à une exécution manuelle de l'algorithme ?
- - - - -
Exercice 2 : Parcours en profondeur
----------
Pour implémenter le parcours en profondeur d'un graphe, nous aurons besoin d'une pile, dont voici la structure et les primitives :
```
struct pile{
int head;
struct pile* suite;
};
typedef struct pile pile;
int emptyPile(pile *p){
return p==NULL;
}
void push(pile **p,int v){
pile* newpile=malloc(sizeof(pile));
newpile->head=v;
newpile->suite=*p;
*p=newpile;
}
int pop(pile **p){
int resultat=(*p)->head;
pile* temp=*p;
*p=(*p)->suite;
free(temp);
return resultat;
}
int first(pile *p){
return p->head;
}
```
On rappelle que pour une variable `pile *fi`, on push 3 en faisant `push(&fi,3)` et on dépile (et on stocke dans une variable x) en faisant `x=pop(&fi)`.
La primitive `x=first(fi)` permet de récupérer le sommet de la pile sans dépiler.
Indice : Vous aurez besoin de la liste des sommets triés selon leur degré, mais également d'un lecteur sur cette liste, i.e. un pointeur vers le début de la liste pouvant la parcourir autrement que par des dequeues.