Fiche de révision

Représentations d'un graphe


Plusieurs modes de représentation peuvent être implémentés pour stocker des graphes : matrices d'adjacence, listes des voisins, des successeurs ou des prédécesseurs.

IMatrice d'adjacence

Une matrice est un tableau de nombres. Elle peut être représentée en machine simplement par une liste de listes. Si on note mat une matrice, l'élément qui est en i-ième ligne et en j-ième colonne est accessible en Python à l'aide de mat[i][j].

Un graphe peut être représenté par une matrice d'adjacence : s'il y a un lien depuis le sommet i vers le sommet j, on pose mat[i][j] = 1 et si il n'y en a pas on pose mat[i][j] = 0. Exemple : graphes et leur matrice d'adjacence.

Tableau de 2 lignes, 2 colonnes ;Corps du tableau de 2 lignes ;Ligne 1 :  M1=110011001;  M2=0110101111010110; Ligne 2 : Graphe 1; Graphe 2;

Lorsqu'un graphe est non orienté sa matrice d'adjacence est symétrique : on a toujours mi,j=mj,i.

Exemple d'une classe GrapheM s'appuyant sur la représentation par matrice d'adjacence (g1 et g2 correspondent aux graphes 1 et 2 ci-dessus) :

Tableau de 18 lignes, 2 colonnes ;Corps du tableau de 18 lignes ;Ligne 1 : ; class GrapheM:; Ligne 2 : ;     def __init__(self, mat):; Ligne 3 : ;         self.m = mat; Ligne 4 : ; ; Ligne 5 : ;     def est_lie(self, i, j):; Ligne 6 : ;         return self.m[i][j] == 1; Ligne 7 : ; ; Ligne 8 : ;     def est_symetrique(self):; Ligne 9 : ;         for i in range(len(self.m)):; Ligne 10 : ;             for j in range(len(self.m[0])):; Ligne 11 : ;                 if self.m[i][j] != self.m[j][i]:; Ligne 12 : ;                     return False; Ligne 13 : ;         return True; Ligne 14 : ; ; Ligne 15 : ; m1 = [[1, 1, 0], [0, 1, 1], [0, 0, 1]]; Ligne 16 : ; g1 = GrapheM(m1); Ligne 17 : ; m2=[[0, 1, 1, 0], [1, 0, 1, 1], [1, 1, 0, 1], [0, 1, 1, 0]]; Ligne 18 : ; g2 = GrapheM(m2);

IIListe des voisins

Pour représenter un graphe, on peut également, pour chacun de ses sommets, donner la liste des sommets auxquels il est relié. Lorsque le graphe est non orienté, on parle de liste de voisins. Lorsqu'il est orienté, on peut décider de représenter un graphe par la liste de ses successeurs ou, lorsque les problèmes que l'on étudie rendent cette représentation plus adaptée, par la liste de ses prédécesseurs.

Nous choisirons de coder ici les sommets avec des nombres (de 0 à n1, où n est l'ordre du graphe) et les listes de successeurs avec des listes, ce qui facilite le passage d'une liste de voisins à la matrice d'adjacence. Il est également possible de coder les listes de successeurs avec des dictionnaires, ce qui permet d'étiqueter les graphes.

Voici un exemple de classe simple implémentant la représentation par liste de successeurs (g3 et g4 correspondent aux graphes 1 et 2 précédents) :

Tableau de 27 lignes, 2 colonnes ;Corps du tableau de 27 lignes ;Ligne 1 : ; class GraphLS:; Ligne 2 : ;     def __init__(self, lst):; Ligne 3 : ;         self.lst = lst; Ligne 4 : ; ; Ligne 5 : ;     def est_lie(self, i, j):; Ligne 6 : ;         return j in self.lst[i]; Ligne 7 : ; ; Ligne 8 : ;     def graph_to_matrix(self):; Ligne 9 : ;         n = len(self.lst); Ligne 10 : ;         mat = [] # Création de la matrice; Ligne 11 : ;         for i in range(n):; Ligne 12 : ;             lst = [0 for i in range(n)] # Création de; Ligne 13 : ;             #la i-ième sous-liste ; n zéros; Ligne 14 : ;             for x in self.lst[i]:; Ligne 15 : ;                 lst[x] = 1 # Il y a un arc de i vers x; Ligne 16 : ;             mat.append(lst); Ligne 17 : ;         return mat; Ligne 18 : ; ; Ligne 19 : ; lst_som1 = [[0, 1], [1, 2], [2]]; Ligne 20 : ; g3 = GraphLS(lst_som1); Ligne 21 : ; ; Ligne 22 : ; lst_som 2 = [[1, 2], [0, 2, 3], [0, 1, 3], [1, 2]]; Ligne 23 : ; g4 = GraphLS(lst_som2); Ligne 24 : ; ; Ligne 25 : ; print(g3.est_lie(0, 2)); Ligne 26 : ; print(g3.graph_to_matrix()); Ligne 27 : ; print(g4.graph_to_matrix());

Pour lire la suite

Je m'abonne

Et j'accède à l'ensemble
des contenus du site