Liste d'adjacence en C ++
- Liste d'adjacence
- Matrice d'adjacence
- Une matrice d'incidence
Le sujet principal de cet article sera la liste d'adjacence. Essayons d'abord de comprendre ce qu'est vraiment un graphique avant d'y entrer pour mieux comprendre cette idée.
Qu'est-ce qu'un graphique?
Un graphique a un nombre fixe de nœuds ou de sommets. Et chaque nœud est connecté par une ligne, que nous appelons un bord. Le bord est pour la communication entre deux sommets ou nœuds. Par exemple, dans le graphique ci-dessus, nous voyons six sommets ou nœuds (0, 1, 2, 3, 4 et 5). À partir du sommet ou du nœud 0, nous pouvons facilement passer au sommet 1 et 3 car il y a une connexion directe entre eux. Mais il n'y a pas de connexion directe entre le sommet ou le nœud 0 et 4.
Les graphiques sont utilisés dans de nombreuses applications réelles pour résoudre des problèmes de réseau. Par exemple, sur Facebook, le profil de l'utilisateur est un nœud ou un sommet, et les amis de l'utilisateur dans la liste sont d'autres nœuds ou sommets différents qui ont des connexions directes entre eux.
Types de graphiques
Il existe principalement deux types de graphiques, des graphiques non dirigés et des graphiques dirigés, les deux sont décrits dans les sections suivantes:
Graphique non dirigée
Le graphique non dirigé est très célèbre car il s'agit d'un graphique bidirectionnel. Par exemple, ci-dessous est un exemple de graphique non dirigé:
Graphique non dirigée
Dans le graphique non dirigé, nous pouvons passer à n'importe quel sommet. Par exemple, s'il existe un lien entre les nœuds A et B, alors nous pouvons également passer de B à un.
Graphique dirigé
Dans un graphique dirigé, les bords ont des bords de direction. Ainsi, ces bords de flèche nous diront comment nous pouvons nous déplacer dans le graphique d'un sommet à un autre sommet, mais seulement dans certaines conditions. Par exemple, s'il y a un bord dirigé entre les nœuds A et B, alors nous pouvons rapidement passer du sommet A à B mais pas de retour de B à A s'il n'y a pas de bord dirigé de B à A.
Graphique dirigé
Liste d'adjacence
La liste d'adjacence est une liste de tableaux où la taille du tableau est égale au nombre de nœuds présents dans le graphique. Et chaque nœud a également un sous-tableau qui représente sa connectivité à d'autres nœuds ou sommets. Nous allons discuter des listes d'adjacence des deux types de graphiques (non dirigés et dirigés).
Liste d'adjacence de graphe non dirigée
Dans le graphique non dirigé ci-dessus, nous pouvons voir six sommets (0, 1, 2, 3, 4, 5). Donc, nous avons un tableau de six sommets. Et chaque autre sommet individuel a sa propre liste liée ou sa liste de contiguïté, comme le montre la liste d'adjacence précédente. Nous pouvons voir que Vertex 0 pointe vers le sommet 4 et le sommet 3.
Mais, comme nous l'avons expliqué auparavant, un graphique non dirigé peut se déplacer dans les deux sens. Il y a un bord entre les nœuds 0 et 4 et une connexion directe entre 0 et 4. Mais en raison du graphique non dirigé, il existe également une connexion entre 4 et 0. C'est pourquoi si vous examinez la liste d'adjacence précédente, le sommet 4 pointe également vers le sommet 0. Il en va de même dans le cas du sommet 3. La liste d'adjacence du sommet 3 pointe également vers le sommet 0.
Liste d'adjacence du graphique réalisé
L'image ci-dessus est un graphique dirigé, et sur le côté droit se trouve sa liste d'adjacence. Dans cette liste d'adjacence, nous pouvons voir un bord direct du nœud 1 au nœud 2 mais pas du nœud 2 à 1. Ainsi, nous ne pouvons nous déplacer que dans une seule direction, c'est-à-dire de 1 à 2. La même chose est également dans la liste d'adjacence. Nous ne pouvons voir aucun lien du sommet 2 à 1 dans la liste d'adjacence de 2.
Matrice d'adjacence
La matrice est utilisée dans cette méthode pour représenter les détails des sommets graphiques. La taille de la matrice dépend du nombre de sommets dans le graphique. Par exemple, si un graphique a 5 sommets, la taille de la matrice sera de 5 x 5. En cela, la ligne et la colonne sont les sommets eux-mêmes. La représentation matricielle de la liste d'adjacence utilise 1 ou 0 pour remplir la matrice. La valeur de 1 représente un chemin du sommet de la ligne au sommet de la colonne, mais la valeur de 0 ne représente aucun chemin entre le sommet de la ligne et le sommet de la colonne.
Liste d'adjacence de la matrice de graphe non dirigée
Dans la liste d'adjacence de la matrice ci-dessus, nous pouvons voir que A à E est valeur 0 car il n'y a pas de chemin entre eux. Donc, nous avons rempli cette valeur avec 0. Mais il y a un chemin du sommet B à A, et nous avons rempli cette valeur avec 1.
Liste d'adjacence de la matrice graphique dirigée
Dans la liste d'adjacence matricielle ci-dessus dirigée, nous pouvons voir que A à D est de valeur 0 car il n'y a pas de chemin de A à D, mais un chemin existe de D à A, donc nous avons rempli cette valeur avec 1.
Matrice d'incidence
La matrice est utilisée dans cette méthode pour représenter les détails des sommets graphiques. La taille de la matrice dépend du nombre de sommets et de bords totaux dans le graphique. Par exemple, si un graphique a 5 sommets et 7 bords, la taille de la matrice sera de 5 x 7. Les bords représenteront les colonnes et les sommets seront du côté de la rangée. La représentation matricielle de la liste d'adjacence utilise 0, 1 ou -1 pour remplir les valeurs de la matrice.
La valeur de 1 représente un chemin sortant du sommet de la ligne au sommet de la colonne, mais la valeur de 0 ne représente aucun chemin entre le sommet de la ligne et le sommet de la colonne. La valeur de -1 représente un chemin entrant vers le bord du sommet de la colonne.
Graphique dirigé
Liste d'adjacence du graphique dirigé
Code C ++ pour la liste d'adjacence du graphique dirigé
#inclure
Utilisation de Namespace Std;
// Syntaxe pour créer un nœud
nœud de structure
INT VALEUR;
Nœud * suivant;
;
// Cela stockera les détails du bord du graphique (source et destination)
struct graphange
INT Source, destination;
;
classe graphadjacencyList
// Créer un nouveau nœud pour la liste d'adjacence
Node * getneighbourvertex (int destination, noeud * head_node)
Nœud * new_node = new nœud;
new_node-> value = destination;
new_node-> next = head_node;
return new_node;
// il stockera le nombre total de nœuds dans un graphique
int number_of_nodes;
public:
Node ** head_node;
GraphAdJacencyList (GraphEdge GraphEdGes [], int num, int number_of_nodes)
// allocation de mémoire dynamique
head_node = new nœud * [number_of_nodes] ();
this-> numéro_of_nodes = numéro_of_nodes;
// Initialiser la norme de tête pour chaque bord du graphique
pour (int k = 0; k < number_of_nodes; k++)
head_node [k] = nullptr;
pour (int k = 0; k < num; k++)
int source = graphedges [k].source;
int destination = graphedges [k].destination;
Node * new_node = getneighbourvertex (destination, head_node [source]);
head_node [source] = new_node;
~ GraphadjacencyList ()
pour (int k = 0; k < number_of_nodes; k++)
delete [] head_node [k];
delete [] head_node;
;
void affichage (noeud * displayPtr)
Pendant (affichage != nullptr)
couter << " adjacency list -> " << displayptr->valeur;
DisplayPtr = displayPtr-> Suivant;
couter << endl;
int main()
GraphEdge Graphés [] =
// Ce sont des valeurs x et y qui représentent un bord de x à y
0, 1, 1, 2, 2, 0, 2, 1, 3, 2, 4, 1, 3, 4
;
// Nombre total de nœuds de 0 à 5, donc le total des nœuds est 6
int number_of_nodes = 6;
// Cette méthode calculera le nombre de bords dans le graphique
int num_edges = sizeof (graphedges) / sizeof (graphedges [0]);
// Créer le graphique
GraphAdJacencyList Graph (GraphEdges, Num_Edges, Number_Of_Nodes);
// Affiche la liste d'adjacence du graphique
pour (int k = 0; k < number_of_nodes; k++)
couter << k;
Afficher (graphique.head_node [k]);
retour 0;
Sortir:
0 Liste d'adjacence -> 1
1 Liste d'adjacence -> 2
2 Liste d'adjacence -> 1 liste d'adjacence -> 0
3 Liste d'adjacence -> 4 Liste d'adjacence -> 2
4 Liste d'adjacence -> 1
5
Graphique réalisé avec des bords de poids
Liste d'adjacence du graphique dirigé
Code C ++ pour la liste d'adjacence du graphique dirigé avec du poids
#inclure
Utilisation de Namespace Std;
// Syntaxe pour créer un nœud
nœud struct
valeur int, coût;
Nœud * suivant;
;
// Cela stockera les détails du bord du graphique (source et destination)
struct graphange
INT Source, destination, poids bord;
;
classe graphadjacencyList
// Créer un nouveau nœud pour la liste d'adjacence
Nœud * getneighbourvertex (INT Destination, int Edgeweight,
Node * head_node)
Nœud * new_node = new nœud;
new_node-> value = destination;
new_node-> cost = edgeweight;
new_node-> next = head_node;
return new_node;
// il stockera le nombre total de nœuds dans un graphique
int number_of_nodes;
public:
Node ** head_node;
GraphAdJacencyList (GraphEdge GraphEdGes [], int num, int number_of_nodes)
// allocation de mémoire dynamique
head_node = new nœud * [number_of_nodes] ();
this-> numéro_of_nodes = numéro_of_nodes;
// Initialiser la norme de tête pour chaque bord du graphique
pour (int k = 0; k < number_of_nodes; k++)
head_node [k] = nullptr;
pour (int k = 0; k < num; k++)
int source = graphedges [k].source;
int destination = graphedges [k].destination;
int edgeweight = graphedges [k].poids de bord;
Nœud * new_node = getneighbourvertex (destination, poids bord,
head_node [source]);
head_node [source] = new_node;
GraphadjacencyList ()
pour (int k = 0; k < number_of_nodes; k++)
delete [] head_node [k];
delete [] head_node;
;
void affichage (node * displayPtr, int k)
Pendant (affichage != nullptr)
couter << "(" << k << ", " <<
DisplayPtr-> valeur << ", " << displayptr->coût << ") ";
DisplayPtr = displayPtr-> Suivant;
couter << endl;
int main()
GraphEdge Graphés [] =
// (x, y, z) => ce sont des valeurs x et y qui représentent un bord
// de x à y avec du poids w
0, 1, 4, 1, 2, 6, 2, 0, 3, 2, 1, 5, 3, 4, 8,
4, 1, 1, 3, 2, 7
;
// Nombre total de nœuds de 0 à 5, donc le total des nœuds est 6
int number_of_nodes = 6;
// Cette méthode calculera le nombre de bords dans le graphique
int num_edges = sizeof (graphedges) / sizeof (graphedges [0]);
// Créer le graphique
GraphAdJacencyList Graph (GraphEdges, Num_Edges, Number_Of_Nodes);
// Affiche la liste d'adjacence du graphique
pour (int k = 0; k < number_of_nodes; k++)
couter << k;
Afficher (graphique.head_node [k], k);
retour 0;
Sortir:
0 (0, 1, 4)
1 (1, 2, 6)
2 (2, 1, 5) (2, 0, 3)
3 (3, 2, 7) (3, 4, 8)
4 (4, 1, 1)
5
Conclusion
Dans cet article, nous avons vu différentes méthodes pour représenter le graphique. Nous avons également vu la matrice d'incidence, qui est également une méthode pour représenter la matrice du graphique. Ensuite, nous avons discuté d'autres méthodes de programmation C ++ pour représenter la liste d'adjacence (graphiques dirigés dirigés et pondérés). Nous avons également étudié les graphiques dirigés et non dirigés. Nous avons également appris qu'un graphique non dirigé est facile à manipuler par rapport à un graphique dirigé car un graphique non dirigé est un graphique bidirectionnel. Après tout, ce n'est pas la direction du bord dépendant comme le graphique dirigé.