Adjazenzliste in C ++
- Adjazenzliste
- Matrix der Adjazenz
- Eine Inzidenzmatrix
Das Hauptthema dieses Artikels wird die Adjazenzliste sein. Versuchen wir zunächst zu verstehen, was eine Grafik wirklich ist, bevor wir uns darauf einlassen, um diese Idee besser zu verstehen.
Was ist eine Grafik?
Ein Diagramm hat eine feste Anzahl von Knoten oder Eckpunkten. Und jeder Knoten ist durch eine Zeile verbunden, die wir eine Kante nennen. Die Kante ist für die Kommunikation zwischen zwei Eckpunkten oder Knoten. Zum Beispiel sehen wir im obigen Diagramm sechs Eckpunkte oder Knoten (0, 1, 2, 3, 4 und 5). Von Scheitelpunkt oder Knoten 0 können wir leicht zu den Scheitelpunkten 1 und 3 übergehen, da zwischen ihnen eine direkte Verbindung besteht. Es gibt jedoch keine direkte Verbindung zwischen Scheitelpunkt oder Knoten 0 und 4.
Diagramme werden in vielen realen Anwendungen verwendet, um Netzwerkprobleme zu lösen. Auf Facebook ist das Profil des Benutzers beispielsweise ein Knoten oder einen Scheitelpunkt, und die Freunde des Benutzers in der Liste sind weitere verschiedene Knoten oder Scheitelpunkte, die direkte Verbindungen zwischen ihnen haben.
Arten von Grafiken
Es gibt hauptsächlich zwei Arten von Graphen, ungerichtete Graphen und gerichtete Graphen, beide sind in den nächsten Abschnitten beschrieben:
Ungerichtete Grafik
Die ungerichtete Grafik ist sehr berühmt, da es sich um eine bidirektionale Grafik handelt. Im Folgenden finden Sie beispielsweise ein Beispiel für eine ungerichtete Grafik:
Ungerichtete Grafik
In der ungerichteten Grafik können wir zu jedem Scheitelpunkt übergehen. Wenn beispielsweise eine Verbindung zwischen den Knoten A und B besteht, können wir auch von B zu A wechseln.
Gerichteter Graph
In einem gerichteten Diagramm haben die Kanten Richtungskanten. Diese Pfeilkanten werden uns also sagen. Wenn beispielsweise eine gerichtete Kante zwischen den Knoten A und B besteht.
Gerichteter Graph
Adjazenzliste
Die Adjazenzliste ist eine Liste von Arrays, in denen die Größe des Arrays gleich der Anzahl der in der Grafik enthaltenen Knoten entspricht. Und jeder Knoten hat auch ein Unterarray, das seine Konnektivität zu anderen Knoten oder Scheitelpunkten darstellt. Wir werden die Adjazenzlisten beider Arten von Graphen diskutieren (ungerichtet und gerichtet).
Ungerichtete Graph -Adjazenzliste
In der obigen ungerichteten Grafik sehen wir sechs Eckpunkte (0, 1, 2, 3, 4, 5). Wir haben also eine Reihe von sechs Eckpunkten. Und jeder weitere einzelne Scheitelpunkt hat eine eigene verlinkte Liste oder Adjazenzliste, wie in der vorherigen Adjazenzliste gezeigt. Wir können sehen, dass der Scheitelpunkt 0 auf Scheitelpunkt 4 und Scheitelpunkt 3 zeigt.
Aber wie wir bereits erklärt haben, kann sich eine ungerichtete Grafik in beide Richtungen bewegen. Es gibt eine Kante zwischen den Knoten 0 und 4 und einer direkten Verbindung zwischen 0 und 4. Aufgrund des ungerichteten Diagramms gibt es aber auch eine Verbindung zwischen 4 und 0. Deshalb zeigt der Scheitelpunkt 4, wenn Sie in die vorherige Adjazenzliste schauen, auch auf den Scheitelpunkt 0 zeigt. Gleiches gilt auch im Fall von Scheitelpunkt 3. Die Adjazenzliste von Scheitelpunkt 3 zeigt auch auf den Scheitelpunkt 0.
Regie Graph Adjazenzliste
Das obige Bild ist eine gerichtete Grafik und auf der rechten Seite seine Adjazenzliste. In dieser Adjazenzliste können wir einen direkten Rand von Knoten 1 bis Node 2 sehen, jedoch nicht von Knoten 2 bis 1. Also können wir uns nur in eine Richtung bewegen, dh von 1 bis 2. Gleiches gilt auch in der Adjazenzliste. In der Adjazenzliste von 2 können wir keinen Link von Scheitelpunkt 2 bis 1 sehen.
Adjazenzmatrix
Die Matrix wird in dieser Methode verwendet, um die Details der Grafikscheitelpunkte darzustellen. Die Größe der Matrix hängt von der Anzahl der Scheitelpunkte in der Grafik ab. Wenn ein Diagramm beispielsweise 5 Eckpunkte hat, beträgt die Größe der Matrix 5 x 5. In diesem Fall sind die Zeile und die Spalte die Eckpunkte selbst. Die Matrixdarstellung der Adjazenzliste verwendet entweder 1 oder 0, um die Matrix zu füllen. Der Wert von 1 repräsentiert einen Pfad vom Zeilenscheitel bis zum Spaltenscheit.
Ungerichtete Graphatrix -Adjazenzliste
In der obigen Matrix -Adjazenzliste können wir sehen, dass a bis e Wert 0 ist, da kein Weg zwischen ihnen besteht. Also haben wir diesen Wert mit 0 gefüllt. Aber es gibt einen Weg von Scheitelpunkt B bis A, und wir haben diesen Wert mit 1 gefüllt.
Regie -Graph -Matrix -Adjazenzliste
In der obigen matrix-Adjazenzliste können wir sehen, dass A bis D Wert 0 ist, da es keinen Weg von A bis D gibt, aber ein Weg von D zu A existiert, also haben wir diesen Wert mit 1 gefüllt.
Inzidenzmatrix
Die Matrix wird in dieser Methode verwendet, um die Details der Grafikscheitelpunkte darzustellen. Die Größe der Matrix hängt von der Anzahl der Eckpunkte und Gesamtkanten in der Grafik ab. Wenn beispielsweise ein Diagramm über 5 Eckpunkte und 7 Kanten verfügt, beträgt die Größe der Matrix 5 x 7. Die Kanten stellen die Spalten dar, und die Eckpunkte befinden sich auf der Zeilenseite. Die Matrixdarstellung der Adjazenzliste verwendet entweder 0, 1 oder -1, um die Matrixwerte zu füllen.
Der Wert von 1 repräsentiert einen ausgehenden Pfad von Zeilenscheitelx. Der Wert von -1 repräsentiert einen eingehenden Pfad zum Rand des Säulenscheitels.
Gerichteter Graph
Adjazenzliste der gerichteten Grafik
C ++ - Code für die Liste der angegebenen Graphen -Adjazenzliste
#enthalten
Verwenden von Namespace STD;
// Syntax zum Erstellen von Knoten
Strukturknoten
int Wert;
Knoten* Weiter;
;
// Dies speichert die Graph -Kantendetails (Quelle und Ziel)
Struct GraphEdge
int Quelle, Ziel;
;
Klasse GraphAdjaCaCyList
// Erstellen Sie einen neuen Knoten für die Adjazenzliste
Knoten* getNeighbourvertex (int destination, knoten* head_node)
Knoten* new_node = neuer Knoten;
new_node-> value = Ziel;
new_node-> next = head_node;
return New_Node;
// Es speichert die Gesamtzahl der Knoten in einer Grafik
int number_of_nodes;
öffentlich:
Knoten ** head_node;
GraphAdJaCaCyList (GraphEdge Graphedges [], int num, int number_of_nodes)
// Dynamische Speicherzuweisung
Head_node = neuer Knoten*[number_of_nodes] ();
this-> number_of_nodes = number_of_nodes;
// Initialisieren Sie die Headnode für jeden Grad des Diagramms
für (int k = 0; k < number_of_nodes; k++)
head_node [k] = nullptr;
für (int k = 0; k < num; k++)
int source = graphedges [k].Quelle;
int destination = graphedges [k].Ziel;
Node* new_node = getneighbourvertex (Ziel, head_node [source]);
head_node [source] = new_node;
~ GraphAdjaCaCyList ()
für (int k = 0; k < number_of_nodes; k++)
delete [] head_node [k];
delete [] head_node;
;
void Display (Knoten* displayPtr)
while (displayPtr != nullptr)
Cout << " adjacency list -> " << displayptr->Wert;
displayPtr = displayPtr-> Weiter;
Cout << endl;
int main ()
GraphEdge Graphedges [] =
// Dies sind X- und Y -Werte, die eine Kante von x nach y darstellen
0, 1, 1, 2, 2, 0, 2, 1, 3, 2, 4, 1, 3, 4
;
// Gesamtzahl der Knoten von 0 bis 5, sodass die Gesamtknoten 6 sind
int number_of_nodes = 6;
// Diese Methode berechnet die Anzahl der Kanten in der Grafik
int num_edges = sizeof (graphedges)/sizeof (graphedges [0]);
// Erstellen Sie die Grafik
GraphAdJaCaCyList -Graph (Graphedges, num_edges, number_of_nodes);
// Zeigen Sie die Adjazenzliste des Diagramms an
für (int k = 0; k < number_of_nodes; k++)
Cout << k;
Anzeige (Diagramm.head_node [k]);
Rückkehr 0;
Ausgang:
0 Adjazenzliste -> 1
1 Adjazenzliste -> 2
2 Adjazenzliste -> 1 Adjazenzliste -> 0
3 Adjazenzliste -> 4 Adjazenzliste -> 2
4 Adjazenzliste -> 1
5
Regie Graph mit Gewichtskanten
Adjazenzliste der gerichteten Grafik
C ++ - Code für die Liste der angegebenen Graphen -Adjazenzliste mit Gewicht
#enthalten
Verwenden von Namespace STD;
// Syntax zum Erstellen von Knoten
Strukturknoten
int Wert, Kosten;
Knoten* Weiter;
;
// Dies speichert die Graph -Kantendetails (Quelle und Ziel)
Struct GraphEdge
int Quelle, Ziel, Edgegewicht;
;
Klasse GraphAdjaCaCyList
// Erstellen Sie einen neuen Knoten für die Adjazenzliste
Knoten* getNeighbourvertex (int destination, int edgegewicht,
Knoten* head_node)
Knoten* new_node = neuer Knoten;
new_node-> value = Ziel;
new_node-> cost = edgegewicht;
new_node-> next = head_node;
return New_Node;
// Es speichert die Gesamtzahl der Knoten in einer Grafik
int number_of_nodes;
öffentlich:
Knoten ** head_node;
GraphAdJaCaCyList (GraphEdge Graphedges [], int num, int number_of_nodes)
// Dynamische Speicherzuweisung
Head_node = neuer Knoten*[number_of_nodes] ();
this-> number_of_nodes = number_of_nodes;
// Initialisieren Sie die Headnode für jeden Grad des Diagramms
für (int k = 0; k < number_of_nodes; k++)
head_node [k] = nullptr;
für (int k = 0; k < num; k++)
int source = graphedges [k].Quelle;
int destination = graphedges [k].Ziel;
int Edgegewicht = Graphedges [k].Edgegewicht;
Knoten* new_node = getNeighbourvertex (Ziel, Edgegewicht,
Head_node [Quelle]);
head_node [source] = new_node;
GraphAdjaCaCyList ()
für (int k = 0; k < number_of_nodes; k++)
delete [] head_node [k];
delete [] head_node;
;
void Display (Knoten* displayPtr, int k)
while (displayPtr != nullptr)
Cout << "(" << k << ", " <<
Anzeigeptr-> Wert << ", " << displayptr->kosten << ") ";
displayPtr = displayPtr-> Weiter;
Cout << endl;
int main ()
GraphEdge Graphedges [] =
// (x, y, z) => Dies sind X- und Y -Werte, die eine Kante darstellen
// von x bis y mit Gewicht w
0, 1, 4, 1, 2, 6, 2, 0, 3, 2, 1, 5, 3, 4, 8,
4, 1, 1, 3, 2, 7
;
// Gesamtzahl der Knoten von 0 bis 5, sodass die Gesamtknoten 6 sind
int number_of_nodes = 6;
// Diese Methode berechnet die Anzahl der Kanten in der Grafik
int num_edges = sizeof (graphedges)/sizeof (graphedges [0]);
// Erstellen Sie die Grafik
GraphAdJaCaCyList -Graph (Graphedges, num_edges, number_of_nodes);
// Zeigen Sie die Adjazenzliste des Diagramms an
für (int k = 0; k < number_of_nodes; k++)
Cout << k;
Anzeige (Diagramm.head_node [k], k);
Rückkehr 0;
Ausgang:
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
Abschluss
In diesem Artikel haben wir verschiedene Methoden gesehen, um die Grafik darzustellen. Wir haben auch die Inzidenzmatrix gesehen, die auch eine Methode zur Darstellung der Grafikmatrix ist. Als nächstes diskutierten wir andere C ++ - Programmiermethoden, um die Adjazenzliste darzustellen (gerichtete und gewichtete gerichtete Diagramme). Wir haben auch gerichtete und ungerichtete Graphen untersucht. Wir haben auch erfahren, dass ein ungerichteter Diagramm im Vergleich zu einem gerichteten Diagramm leicht zu handhaben ist, da ein ungerichteter Diagramm ein bidirektionales Diagramm ist. Immerhin ist es nicht wie die gerichtete Grafik abhängig.