Modèles d’implantation

Modèles d’implantation
Il existe plusieurs manières de représenter les graphes. Entre autres, sous forme graphique sous forme de listes de sommets et d'arcs. La représentation graphique d'un graphe n'est toutefois utilisable que par un humain et uniquement si le graphe est peu dense ou contient relativement peu de sommets.

La description sous forme de listes de sommets et d'arcs de ce graphe. G = (NOEUDS, ARC) NOEUDS = {A, B, C, D, E, F, G, H, I} ARCS = {AC, AD, BA, BB, BF, CE, CG, DA, ED, HE, HG}

Deux principales méthodes de modélisation des graphes en tant que type abstrait: les matrices et les listes dites de connectivité ou d'adjacence. Le choix entre elles se fera en fonction de la densité du graphe. Par densité, on entend la proportion d'arcs effectifs par rapport au nombre maximum d'arcs possibles (NbArcs / NbSommets2).

Matrice de connectivité ou de noeuds adjacents Une matrice de valeurs booléennes de dimension NbSommets*NbSommets pour indiquer qu'il y a un arc entre un sommet x et un sommet y. Cette méthode de représentation est indiquée si le graphe est dense car il faut NbSommets2 booléens pour stocker le graphe et NbSommets2 étapes pour initialiser la matrice.

1 2 5 4 3 matrice d’adjacence : 1 2 3 4 5 1 1 2 1 1 3 4 1 1 5 1

Matrice d’adjacence Sommet int no; int tag; BOOL pres; char *nom; 1 2
#define NB_SOMMET 5 typedef struct { Sommet sommets[NB_SOMMET]; BOOL arc[NB_SOMMET][NB_SOMMET]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; 1 2 3 4 5 1 2 5 4 3

Matrice triangulaire Sommet int no; int tag; BOOL pres; char *nom; 1 2
#define NB_SOMMET 5 typedef struct { Sommet sommets[NB_SOMMET]; BOOL arc[NB_SOMMET][NB_SOMMET]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; 1 2 3 4 5 1 2 5 4 3

matrice d’adjacence : (avec graphe non orienté)
Matrice triangulaire 1 2 5 4 3 matrice d’adjacence : (avec graphe non orienté) On peut, pour un graphe non-orienté, économiser de l'espace en ne stockant que le triangle supérieur de la matrice symétrique. Matrice triangulaire possède n = [n (n+1)] / 2 éléments. On la représente dans un vecteur ayant ce même nombre d'éléments. Si on la range par ligne, alors le vecteur aura l'allure suivante : A11 A21 A22 A31 A32 A33 A Ann

Matrice triangulaire matrice d’adjacence : (avec graphe non orienté) 1
2 5 4 3 matrice d’adjacence : (avec graphe non orienté) Matrice triangulaire. Si A11 est en position 1 (indice inférieur du vecteur), alors l'adresse de Aij est donnée par : Adresse = A0 + ( i - 1 ) * i / 2 + j Ainsi, la position de A42 est A0 + 8. Des matrices symétriques, pour lesquelles Aij = Aji pour peuvent être également représentées de cette façon.

Linéarisation d’une matrice
int main() { int *tab; int i, j, k=0; tab=(int*)calloc(MAX_LIGNES*MAX_COLONNES,sizeof(int)); for (i=0; i<MAX_LIGNES; i++) for (j=0; j<MAX_COLONNES; j++) set(tab, k++, i, j); } { for (j=0; j<MAX_COLONNES; j++) printf("%d ", get(tab, i, j)); printf("\n"); free(tab); return 0; Linéarisation d’une matrice void set (int *tab, int x, int i, int j) { tab[MAX_COLONNES*i + j] = x; } int get(int *tab, int i, int j) return tab[MAX_COLONNES*i + j];

Linéarisation d’une matrice triangulaire
int main() { int *tab; int i, j, k=0; tab=(int*) calloc( MAX_LIGNES*( MAX_LIGNES+1)/2, sizeof(int)); for (i=0; i<MAX_LIGNES; i++) for (j=0; j<=i; j++) set(tab, k++, i, j); } printf("%d ", get(tab, i, j) ); printf("\n"); free(tab); return 0; Linéarisation d’une matrice triangulaire void set (int *tab, int x, int i, int j) { tab[i*(i+1)/2 + j] = x; } int get(int *tab, int i, int j) return tab[i*(i+1)/2 + j];

#include "ModeleImplantationTabInt.h"
#define OK 0 #define PAM 1 TabInt initTabInt(int *err); /* ..*/ int * set (int *tab, int x, int i, int j, int *err); /* permet de placer la donnée x dans la matrice en (i, j) exactement si on aurait à faire: tab[i][j] */ int get(int *tab, int i, int j, int *err); /* get permet de lire l'élément de matrice en (i,j) */ TabInt destroyTabInt(TabInt tab, int *err); /* */ #include <stdlib.h> #define MAX_LIGNES 2 #define MAX_COLONNES 3 typedef int * TabInt;

#include "TabInt.h" int main() { TabInt tab; int i, j, k=0; int err; tab= initTabInt(&err); /*tab= initTab(INT, 2, 3, &err);*/ for (i=0; i<MAX_LIGNES; i++) { for (j=0; j<MAX_COLONNES; j++) set(tab, k++, i, j, &err); } printf("%d ", get(tab, i, j, &err)); printf("\n"); tab= destroyTabInt(tab, &err); return 0;

Matrice triangulaire #define NB_SOMMET 5 typedef struct {
Sommet sommets[NB_SOMMET]; BOOL arc[15]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; 1 2 5 1 1 1 1 4 2 1 1 3 3 1 4 1 1 1 1 ( i + 1 ) * i / 2 + j 5 1 1 1 1 1 1 1 1

Sommet sommets[NB_SOMMET]; BOOL * arc[NB_SOMMET]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; 1 2 3 4 5 1 2 3 4 5 1 1 1 1 1 2 1 1 2 1 3 1 3 4 1 1 1 1 4 1 1 1 5 1 1 5 1 1

Matrice triangulaire + #define NB_SOMMET 5 typedef struct {
Sommet sommets[NB_SOMMET]; BOOL * arc[NB_SOMMET]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; BOOL *arc; + 1 2 3 4 5 1 2 3 4 5 1 1 1 1 1 2 1 1 2 1 3 1 3 4 1 1 1 1 4 1 1 1 5 1 1 5 1 1

Sommet sommets[NB_SOMMET]; int * arc[NB_SOMMET]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; 1 2 3 4 5 1 1 1 1 1 2 1 1 2 1 3 1 3 4 1 1 1 1 4 1 2 3 5 1 1 5 1 4

Matrice triangulaire + #define NB_SOMMET 5 typedef struct {
Sommet sommets[NB_SOMMET]; int * arc[NB_SOMMET]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; int *arc; + 1 2 3 4 5 1 1 1 1 1 2 1 1 2 1 3 1 3 4 1 1 1 1 4 1 2 3 5 1 1 5 1 4

Listes d’adjacence #define NB_SOMMET 5 typedef struct {
Sommet sommets[NB_SOMMET]; int * arc[NB_SOMMET]; } Graphe; Sommet int no; int tag; BOOL pres; char *nom; int *arc; 1 2 3 4 5 1 1 1 1 1 2 1 1 2 1 3 1 3 4 1 1 1 1 4 1 2 3 5 1 1 5 1 4

Listes d’adjacence Sommet int no; int tag; BOOL pres; char *nom;
Noeud *arc; C D G E F typedef struct noeud { int numSommetAdj; struct noeud* suivant; } Noeud; typedef struct int nbNoeud; Sommet * listeNoeud; }Graphe; H N u m é r o N o m P t r . L i s t e s d e s n o e u d s a d j a c e n t s a u n e n o e u d 1 A 3 4 2 B 1 2 6 3 C 5 7 4 D 1 5 E 4 6 F 7 G 8 H 5 7 9 I

Listes d’adjacence L'occupation mémoire d'une matrice de connectivité est inférieure à l'occupation mémoire de la liste de connectivité correspondante dès que la densité des arcs dépasse 3 %. La structure de liste nécessite moins d'étapes d'initialisation et de traitement mais cet avantage devient de moins en moins déterminant au fur et à mesure que la densité des arcs augmente. Il y a donc un compromis à trouver entre gain de temps et gain d’espace.

Listes croisées 4 2 5 3 1 1 2 3 4 5 1 1 1 1 2 1 1 2 3 3 4 1 1 4 5 1 5

Listes croisées 4 2 5 3 1 1 2 3 4 5 1 1 1 1 2 1 1 2 1 1 3 3 4 1 1 4 1 1 5 1 5 1

Structure entièrement dynamique
4 2 5 3 1 ... 1 2 3 4 5 1 1 1 1 2 1 1 2 1 1 3 3 4 1 1 4 1 1 5 1 5 1

Un modèle pour modéliser les dessertes d’une compagnie aérienne 4 2 5 3 1 ... 1 2 3 4 5 1 1 1 1 2 1 1 2 1 1 3 3 4 1 1 4 1 1 5 1 5 1

typedef struct /*Modèle pour un graphe*/ { int nb_noeuds; /*Le nombre de noeuds dans le graphe*/ Noeud* noeudsOrigine; /*Pointeur sur les noeuds d'origine)*/ Noeud* noeudsDestination; /*Pointeur sur les noeuds de destination)*/ }Graphe; ...

typedef struct noeud /* Un noeud dans un graphe*/ { int numero; /*Le nom de la ville associée noeud*/ Arete* liste_adjacence; /*La liste des arêtes adjacentes*/ int status; /*Pour la recherche par contagion*/ struct noeud* suivant; /*Le prochain noeud de la liste*/ }Noeud; 1 2 3 4 5

typedef struct Arete /*Une arête d'un graphe*/ { int numero_origine; /*Le numéro de la ville d'origine*/ int numero_destination; /*Le numéro de la ville de destination*/ float temps_vol; /*Pondération de l ’arête*/ struct Arete* suivante1; /*Prochaine adjacence du noeud sur une rangée*/ struct Arete* suivante2; /*Prochaine adjacence du noeud sur une colonne*/ }Arete; 1

On peut également envisager d'utiliser une autre structure entièrement dynamique en créant une chaîne décrivant les sommets du graphe, où chaque élément contiendrait le nom d'un sommet, un pointeur vers le sommet suivant ainsi qu'un pointeur vers une chaîne décrivant les arcs partant de ce sommet. On aurait ainsi une chaîne des sommets et, pour chaque élément de cette chaîne, une chaîne des arcs. Cela pourrait donner la structure suivante ...

TP2 Automne 2005 Réseau Internet Reseau ListeDeConnexions Serveur
NoeudChaine Connexion

TP2 Automne 2005 typedef struct
{ int nbAretes; /* nb de liens dans le réseau */ int nbSommets; /* nb de serveurs dans le réseau */ NoeudChaine *serveurs; /* liste chaînée des serveurs*/ } Reseau; /* représente tout le réseau */

TP2 Automne 2005 typedef struct SNoeudChaine /* Liste chaînée de serveurs */ { Serveur s; struct SNoeudChaine *suivant; /* pointeur suivant */ struct SNoeudChaine *precedent; /* pointeur précédent */ }NoeudChaine;

TP2 Automne 2005 typedef struct {
Etiquette etiquette; /* étiquette d’un serveur*/ ListeDeConnexions connexions; /* liste de ces connexions */ EtatParcours etat; /* pour les parcours */ } Serveur;

TP2 Automne 2005 typedef struct {
Connexion *premier; /* vers le début de la liste des connexions */ int card; /* le nombre d’éléments dans la liste */ } ListeDeConnexions;

TP2 Automne 2005 typedef struct connexion {
NoeudChaine *destination; /* pointeur sur le serveur s2 */ int charge; /* charge de l'arc s1-s2 */ struct connexion *suivant; /* vers un serveur adjacent à s1*/ } Connexion ; /* Connexion entre 2 serveurs s1 et s2 par exemple*/

Laboratoire #5 typedef struct noeud {
TypeEl sommet; /* l'étiquette d'un sommet */ struct noeud* suivant; /* les listes de noeuds adjacents */ } Noeud; /* le noeud typique du graphe */ typedef struct int nbNoeud; /* nombre de sommets */ TypeEl * tableauSommet; /* tableau des sommets*/ Noeud** listeNoeud; /* les listes de noeuds adjacents*/ }Graphe; /* le graphe */

1 2 3 Laboratoire #5 1 2 3 1 3 2 1 2 typedef struct noeud {
1 1 3 2 2 1 3 2 typedef struct noeud { TypeEl sommet; struct noeud* suivan } Noeud; typedef struct { int nbNoeud; TypeEl * tableauSommet; Noeud** listeNoeud; }Graphe;

Laboratoire#5 typedef struct nœud NœudAdjacent; typedef struct {
int sommet; int status; Bool present; NoeudAdjacent * listeNoeud; } TypeEl; /* un sommet du graphe */ struct noeud TypeEl sommet; struct noeud* adjacent; /* les listes de noeuds adjacents */ }; int nbNoeud; /* nombre de sommets */ TypeEl * tableauSommet; /* tableau des sommets*/ }Graphe; /* le graphe */ Laboratoire#5

int sommet; int status; Bool present; NoeudAdjacent * listeNoeud; } TypeEl; /* un sommet du graphe */ struct noeud TypeEl * sommet; struct noeud* adjacent; /* les listes de noeuds adjacents */ }; int nbNoeud; /* nombre de sommets */ TypeEl * tableauSommet; /* tableau des sommets*/ }Graphe; /* le graphe */ Laboratoire#5

int sommet; int status; Bool present; NoeudAdjacent * listeNoeud; } TypeEl; /* un sommet du graphe */ struct noeud TypeEl * sommet; int cout; struct noeud* adjacent; /* les listes de noeuds adjacents */ }; int nbNoeud; /* nombre de sommets */ TypeEl * tableauSommet; /* tableau des sommets*/ }Graphe; /* le graphe */ Laboratoire#5

int sommet; int val; int status; Bool present; NoeudAdjacent * listeNoeud; } TypeEl; /* un sommet du graphe */ struct noeud TypeEl * sommet; int cout; struct noeud* adjacent; /* les listes de noeuds adjacents */ }; int nbNoeud; /* nombre de sommets */ TypeEl * tableauSommet; /* tableau des sommets*/ }Graphe; /* le graphe */ Laboratoire#5

Laboratoire#5 typedef struct nœud NœudAdjacent; typedef struct Tnoeud
{ int sommet; int val; int status; Bool present; NoeudAdjacent * listeNoeud; struct Tnoeud * autreSommet; } TypeEl; /* un sommet du graphe */ struct noeud { TypeEl * sommet; int cout; struct nœud * adjacent; /* les listes de noeuds adjacents */ }; typedef struct int nbNoeud; /* nombre de sommets: optionnel */ TypeEl * tableauSommet; /* liste chaînée des sommets*/ } Graphe; /* le graphe */ Laboratoire#5

typedef struct tarete TArete;
typedef struct tnoeudObjet { int x, y; TArete *NoeudAdj; struct tnoeudObjet *Suivant; }TNoeudObjet; struct tarete TNoeudObjet *Objets; int cout; TArete *Suivant; }; typedef struct TNoeudObjet *ListObjets; }Labyrinthe;

Exercice Écrire le modèle d’implantation Écrire Graphe init(int *err); Écrire Graphe detruireGraphe(Graphe g, int *err);

/* Structure pour représenter le graphe */
typedef struct { Sommet *lstSommets; /* la liste des sommets du Graphe */ } Graphe ;

/* Structure pour représenter un sommet du graphe */
typedef struct sommet { int etiquette; /* étiquette du Sommet */ int etat; /* état pour le parcours. 1 : Prêt , 2 : Attente , 3 : Traité */ struct sommet *smtSuivant; /*pointeur sur le prochain sommet dans la liste de sommets du Graphe*/ Arc *lstArc; /* la liste d'adjacence du Sommet */ } Sommet;

/* Structure pour la liste d'adjacence */
typedef struct arc { Sommet *smtAdj; /* pointeur sur le sommet adjacent */ struct arc *arcSuivant; /* Pointeur sur le prochaine arc*/ }Arc;

Corrigé typedef struct arc Arc; typedef struct sommet Sommet;
/* Structure pour la liste d'adjacence */ struct arc { Sommet *smtAdj; /* pointeur sur le sommet adjacent */ Arc *arcSuivant; /* Pointeur sur le prochaine arc */ }; /* Structure pour représenter un sommet du graphe */ struct sommet int etiquette; /* étiquette du Sommet */ int etat; /* état pour le parcours. 1 : Prêt , 2 : Attente , 3 : Traité */ Sommet *smtSuivant; /*pointeur sur le prochain sommet dans la liste de sommets du Graphe*/ Arc *lstArc; /* la liste d'adjacence du Sommet */ } ; /* Structure pour représenter le graphe */ typedef struct Sommet *lstSommets; /* la liste des sommets du Graphe */ } Graphe ; Corrigé

Modèles d’implantation

Présentations similaires

Présentation au sujet: "Modèles d’implantation"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Modèles d’implantation

Présentations similaires

Présentation au sujet: "Modèles d’implantation"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back