Gerichteter Graph

Ein gerichteter Graph mit 3 Knoten und 4 gerichteten Kanten (Doppelpfeil entspricht zwei gegenläufigen Pfeilen)

Ein gerichteter Graph oder Digraph (von englisch directed graph) besteht aus

einer Menge <math>V</math> von Knoten ({{#invoke:Vorlage:lang|full|CODE=en|SCRIPTING=Latn|SERVICE=englisch}}, oft auch Ecken genannt) und
einer Menge geordneter Knotenpaare <math>E \subseteq V \times V</math> von Kanten.<ref name="Diestel2010">{{#invoke:Vorlage:Literatur|f}}</ref>

Die Kanten <math>(v,w) \in E</math> eines gerichteten Graphen sind gerichtete Kanten ({{#invoke:Vorlage:lang|full|CODE=en|SCRIPTING=Latn|SERVICE=englisch}}, manchmal auch Bögen). Diese werden häufig als Pfeile dargestellt und können nur in einer Richtung durchlaufen werden. Im Gegensatz dazu sind die Kanten eines ungerichteten Graphen ungeordnete Knotenpaare <math>\{v,w\}</math>. Gerichtete Graphen werden dazu benutzt, Objekte und die dazwischenliegenden Verbindungen, beispielsweise von endlichen Automaten, darzustellen.

Grundbegriffe

Ein gerichteter Graph ohne Mehrfachkanten und Schleifen wird einfacher Digraph<ref>{{#invoke:Vorlage:Literatur|f}}</ref> (auch schlichter Digraph) genannt.

Man sagt, dass eine gerichtete Kante <math>e = (x, y)</math> von <math>x</math> nach <math>y</math> geht. Dabei ist <math>x</math> der Fuß (oder Startknoten) und <math>y</math> der Kopf (oder Endknoten) von <math>e</math>. Weiterhin gilt <math>y</math> als der direkte Nachfolger von <math>x</math> und <math>x</math> als der direkte Vorgänger von <math>y</math>. Falls in einem Graphen von <math>x</math> nach <math>y</math> ein Pfad führt, gilt <math>y</math> als ein Nachfolger von <math>x</math> und <math>x</math> als ein Vorgänger von <math>y</math>. Die Kante <math>(y, x)</math> heißt umgedrehte oder invertierte Kante von <math>(x, y)</math>.

Ein gerichteter Graph <math>G</math> heißt symmetrisch, falls <math>G</math> zu jeder Kante auch die entsprechende invertierte Kante enthält. Ein ungerichteter Graph lässt sich einfach in einen symmetrischen gerichteten Graphen umwandeln, indem man jede Kante <math>\{x, y\}</math> durch die zwei gerichteten Kanten <math>(x, y)</math> und <math>(y, x)</math> ersetzt.

Um eine Orientierung eines einfachen ungerichteten Graphen zu erhalten, muss jeder Kante eine Richtung zugewiesen werden. Jeder auf diese Art konstruierte gerichtete Graph wird orientierter Graph genannt. Ein einfach gerichteter Graph darf, im Gegensatz zum orientierten Graphen, zwischen zwei Knoten Kanten in beide Richtungen enthalten.<ref name="Diestel2010" /><ref>{{#if: | {{{author}}} | Eric W. Weisstein }}: Oriented Graph. In: MathWorld (englisch). {{#if: OrientedGraph | {{#ifeq: {{#property:P2812}} | OrientedGraph | | {{#if: {{#property:P2812}} | {{#ifeq: 0 | 0 | }} | {{#ifeq: 0 | 0 | }} }} }} }}</ref><ref>{{#if: | {{{author}}} | Eric W. Weisstein }}: Graph Orientation. In: MathWorld (englisch). {{#if: GraphOrientation | {{#ifeq: {{#property:P2812}} | GraphOrientation | | {{#if: {{#property:P2812}} | {{#ifeq: 0 | 0 | }} | {{#ifeq: 0 | 0 | }} }} }} }}</ref>

Ein gewichteter Digraph ist ein Digraph, dessen Kanten Gewichte zugeordnet werden, wodurch man einen kantengewichteten Graphen erhält. Ein Digraph mit gewichteten Kanten wird in der Graphentheorie als Netzwerk bezeichnet.<ref>{{#invoke:Vorlage:Literatur|f}}</ref>

Die Adjazenzmatrix eines Digraphen (mit Schleifen und Mehrfachkanten) ist eine ganzzahlige Matrix, deren Zeilen und Spalten den Knoten des Digraphen entsprechen. Ein Eintrag <math>a_{ij}</math> außerhalb der Hauptdiagonalen gibt die Anzahl der Kanten vom Knoten <math>i</math> zum Knoten <math>j</math> an, und der Eintrag der Hauptdiagonalen <math>a_{ii}</math> entspricht der Anzahl der Schleifen im Knoten <math>i</math>. Die Adjazenzmatrix eines Digraphen ist bis auf Vertauschung von Zeilen und Spalten eindeutig.

Ein Digraph lässt sich auch durch eine Inzidenzmatrix repräsentieren.

Zusammenhängende gerichtete Graphen

{{#if: Zusammenhang (Graphentheorie)|{{#ifexist:Zusammenhang (Graphentheorie)|

|{{#if: |{{#ifexist:{{{2}}}|

→ Haupt{{#if:|seite|artikel}}: [[{{{2}}}{{#if: ||{{{titel2}}}}}]]{{#if: |{{#ifexist:{{{3}}}| und [[{{{3}}}{{#if: ||{{{titel3}}}}}]]|}}|}}

|{{#if: |{{#ifexist:{{{3}}}|

→ Haupt{{#if:|seite|artikel}}: [[{{{3}}}{{#if: ||{{{titel3}}}}}]]

|}}|}}|}}|}}|}}|Einbindungsfehler: Die Vorlage Hauptartikel benötigt immer mindestens ein Argument.}}

Ein gerichteter Graph <math>G</math> heißt schwach zusammenhängend (oder nur zusammenhängend),<ref>Bang-Jensen, Gutin: Digraphs: Theory, Algorithms and Applications, 2. Auflage, 2009, S. 20.</ref> falls der unterliegende Graph von <math>G</math>, den man mittels Ersetzung aller gerichteter Kanten durch ungerichtete erhält, ein zusammenhängender Graph ist. Ein gerichteter Graph heißt stark zusammenhängend oder stark, wenn je zwei seiner Knoten gegenseitig erreichbar sind. Ein maximaler stark zusammenhängender Untergraph von <math>G</math> ist eine starke Komponente.

Eingangs- und Ausgangsgrad

Datei:DirectedDegrees.svg

Digraph mit Knotenbeschriftung (Eingangs- und Ausgangsgrad).

{{#if: Grad (Graphentheorie)#Gerichtete Graphen|{{#ifexist:Grad (Graphentheorie)#Gerichtete Graphen|

|{{#if: |{{#ifexist:{{{2}}}|

→ Haupt{{#if:|seite|artikel}}: [[{{{2}}}{{#if: ||{{{titel2}}}}}]]{{#if: |{{#ifexist:{{{3}}}| und [[{{{3}}}{{#if: ||{{{titel3}}}}}]]|}}|}}

|{{#if: |{{#ifexist:{{{3}}}|

→ Haupt{{#if:|seite|artikel}}: [[{{{3}}}{{#if: ||{{{titel3}}}}}]]

|}}|}}|}}|}}|}}|Einbindungsfehler: Die Vorlage Hauptartikel benötigt immer mindestens ein Argument.}}

Die Anzahl der direkten Vorgänger eines Knotens wird Eingangsgrad (auch Innengrad) und die Anzahl der direkten Nachfolger Ausgangsgrad (oder Außengrad) genannt.

Der Eingangsgrad eines Knotens <math>v</math> in einem Graphen <math>G</math> wird mit <math>d_G^-(v)</math> und der Außengrad mit <math>d_G^+(v)</math> bezeichnet. Ein Knoten mit <math>d_G^-(v)=0</math> wird Quelle und ein Knoten mit <math>d_G^+(v)=0</math> wird Senke genannt. Eine Senke heißt universelle Senke, falls sie eingehende Kanten von jedem anderen Knoten hat, falls also ihr Eingangsgrad gleich <math>|V|-1</math> ist.

Für gerichtete Graphen ist die Summe aller Eingangsgrade gleich der Summe aller Ausgangsgrade, und beide gleich der Summe der gerichteten Kanten:

Falls für alle Knoten <math>v \in V</math> die Gleichung <math>d_G^+(v) = d_G^-(v)</math> gilt, wird der Graph balancierter Digraph genannt.<ref>{{#invoke:Vorlage:Literatur|f}}</ref><ref>{{#invoke:Vorlage:Literatur|f}}</ref>

Darstellung von gerichteten Graphen

Datei:4node-digraph-embed.svg

Der im Beispiel behandelte gerichtete Graph

Außer der naiven Darstellung eines gerichteten Graphen durch Angabe der Knoten- und Kantenmenge gibt es noch weitere Darstellungsmöglichkeiten, das sogenannte Kanten bzw. Knotenfeld.

Kantenfeld

Ein Kantenfeld ist eine Darstellungsart für gerichtete Graphen nach folgendem Schema:

<math>|V|, |E|, E_1,\ldots, E_{|E|}</math>,

wobei <math>|V|</math> die Anzahl der Knoten, <math>|E|</math> die Anzahl der Kanten und <math> E_1, \ldots, E_{|E|}</math> die Kanten mit <math> E_i = (v, w) \in E </math> sind.

Knotenfeld

Ein Knotenfeld ist eine Darstellungsart für gerichtete Graphen mit folgendem Aufbau:

<math>|V|, |E|, \text{ag}(V_1), \text{Ziel}_1, \ldots, \text{Ziel}_{\text{ag}(V_1)}, \ldots, \text{ag}(V_{|V|}), \text{Ziel}_1, \ldots, \text{Ziel}_{\text{ag}(V_{|V|})}</math>,

wobei <math>|V|</math> die Anzahl der Knoten, <math>|E|</math> die Anzahl der Kanten und <math>\operatorname{ag}(V)</math> der Ausgangsgrad des Knotens <math>V</math> sind.

Beispiel

Betrachtet man als Beispiel den rechts stehenden gerichteten Graph, so ist das Kantenfeld <math> 4,6,(1,2),(1,4),(2,4),(3,1),(3,2),(4,3)</math> und das Knotenfeld <math>4,6,\mathbf{2},2,4,\mathbf{1},4,\mathbf{2},1,2,\mathbf{1},3</math>. Die fett gedruckten Zahlen geben den Ausgangsgrad an.

Klassen von gerichteten Graphen

Datei:Directed acyclic graph 2.svg

Einfach gerichteter azyklischer Graph

Datei:4-tournament.svg

Turniergraph mit 4 Knoten

Symmetrisch gerichtete Graphen sind gerichtete Graphen, bei denen alle Kanten bidirektional sind, d. h. für jede Kante, die zum Graphen gehört, gehört auch die entsprechende umgekehrte Kante dazu.

Einfache gerichtete Graphen sind gerichtete Graphen ohne Schleifen und ohne Mehrfachkante.

Vollständige gerichtete Graphen sind einfache gerichtete Graphen, bei denen jedes Knotenpaar durch ein symmetrisches Paar gerichteter Kanten verbunden ist. Dies entspricht einem ungerichteten vollständigen Graphen, dessen Kanten durch Paare von gerichteten Kanten ersetzt werden. Daraus folgt, dass ein vollständiger gerichteter Graph symmetrisch ist.

Orientierte Graphen sind gerichtete Graphen ohne bidirektionale Kanten. Daraus folgt, dass ein gerichteter Graph genau dann ein orientierter Graph ist, wenn er keinen 2-Zyklus hat.

Turniergraphen sind orientierte Graphen, die durch Auswahl einer Richtung für jede Kante in ungerichteten vollständigen Graphen erhalten werden.

Ein gerichteter azyklischer Graph oder azyklischer Digraph ist ein gerichteter Graph, der keinen gerichteten Kreis enthält. Spezialfälle gerichteter azyklischer Graphen sind Mehrfachbäume (je zwei gerichtete Pfade des Graphen, die vom selben Startknoten ausgehen, dürfen sich nicht im selben Endknoten treffen), orientierte Bäume oder Polybäume (Orientierung eines ungerichteten azyklischen Graphen) und Wurzelbäume (orientierte Bäume, bei denen alle Kanten des unterliegenden ungerichteten Baumes vom Wurzelknoten wegführen).

Gewichtete gerichtete Graphen oder gerichtete Netzwerke sind einfache gerichtete Graphen mit Gewichten, die ihren Kanten zugewiesen sind, ähnlich wie gewichtete Graphen, die auch als ungerichtete Netzwerke oder gewichtete Netzwerke bezeichnet werden.

Flussnetzwerke sind gewichtete gerichtete Graphen mit zwei speziellen Knoten, der Quelle und der Senke.

Kontrollflussgraphen sind gerichtete Graphen, die in der Informatik zur Darstellung der Pfade verwendet werden, die während der Ausführung eines Computerprogramms durchlaufen werden können.

Signalflussgraphen sind gewichtete gerichtete Graphen, in denen Knoten Systemvariablen darstellen und Kanten funktionale Verbindungen zwischen Knotenpaaren darstellen.

Zustandsübergangsdiagramme sind gerichtete Multigraphen, die endliche Automaten darstellen.

Kommutative Diagramme sind gerichtete Graphen, die in der Kategorientheorie verwendet werden, wobei die Knoten mathematische Objekte und die Kanten mathematische Funktionen darstellen, mit der Eigenschaft, dass alle gerichteten Pfade mit demselben Start- und Endknoten durch Komposition zum gleichen Ergebnis führen.

Kombinatorik

Die Anzahl der einfachen gerichteten Graphen mit <math>n</math> Knoten steigt rasant mit der Anzahl der Knoten und ist gleich <math>4^{\tfrac{n \cdot (n - 1)}{2}}</math>. Sie steigt also exponentiell zur Anzahl <math>\tfrac{n \cdot (n - 1)}{2}</math> der Kanten des vollständigen Graphen <math>K_n</math>. Wenn die Knoten nicht nummeriert sind, isomorphe Graphen also nicht mitgezählt werden, ist diese Anzahl etwa proportional zu <math>\tfrac{1}{n!} \cdot 4^{\tfrac{n \cdot (n - 1)}{2}}</math>, weil für die meisten Isomorphieklassen alle <math>n!</math> Graphen, die sich durch Permutation der nummerierten Knoten ergeben, verschieden sind. Die folgende Tabelle zeigt die mit Hilfe eines Computers bestimmten Anzahlen für <math>n \leq 8</math>:<ref>Folge A000088 in OEIS</ref><ref>Folge A003085 in OEIS</ref><ref>Folge A035512 in OEIS</ref>

Anzahl der gerichteten Graphen ohne nummerierte Knoten
n	alle	zusammenhängend	stark zusammenhängend
1	1	1	1
2	3	2	1
3	16	13	5
4	218	199	83
5	9608	9364	5048
6	1540944	1530843	1047008
7	882033440	880471142	705422362
8	1793359192848	1792473955306	1580348371788

Programmierung

Das folgende Beispiel in der Programmiersprache C++ zeigt die Implementierung eines gerichteten Graphen mit Adjazenzlisten. Der gerichtete Graph wird als Klasse DirectedGraph deklariert. Bei der Ausführung des Programms wird die Methode main verwendet.<ref>Software Testing Help: Graph Implementation In C++ Using Adjacency List</ref> <syntaxhighlight lang="cpp">

include <iostream>

using namespace std;

// Deklariert den Datentyp für die Knoten des Graphen struct Node {

   int index;
   string value;
   Node* next;

};

// Deklariert den Datentyp für die Kanten des Graphen struct Edge {

   int startIndex;
   int endIndex;

};

// Deklariert die Klasse für den gerichteten Graphen class DirectedGraph { public:

   Node** headNode;

   // Diese Methode fügt einen neuen Knoten in die Adjazenzliste des Graphen ein und gibt ihn als Rückgabewert zurück
   Node* insertNewNode(int index, string value, Node* node)
   {
       Node* newNode = new Node; // Erzeugt einen neuen Knoten vom Typ Node
       newNode->index = index; // Setzt den Index
       newNode->value = value; // Setzt den Wert
       newNode->next = node; // Setzt einen Zeiger auf den Nachfolger
       return newNode;
   }

   // Konstruktor, der den gerichteten Graphen mit den gegebenen Knoten und Kanten erzeugt
   DirectedGraph(Node nodes[], Edge edges[], int numberOfEdges, int numberOfNodes)
   {
       headNode = new Node*[numberOfNodes](); // Initialisiert ein Array von Zeigern für die Knoten
       for (int i = 0; i < numberOfEdges; i++) // for-Schleife, die alle Kanten des Graphen durchläuft
       {
           int startIndex = edges[i].startIndex; // Index des Startknotens der Kante
           int endIndex = edges[i].endIndex; // Index des Endknotens der Kante
           string value = nodes[endIndex].value; // Wert des Endknotens der Kante
           Node* newNode = insertNewNode(endIndex, value, headNode[startIndex]); // Aufruf der Methode insertNewNode, um einen neuen Knoten einzufügen
           headNode[startIndex] = newNode; // Setzt den Zeiger auf den neuen Knoten
       }
   }

};

// Gibt alle benachbarten Knoten von node auf der Konsole aus void writeAdjacencyList(Node* node, int i) {

   cout << "Knoten " << (i + 1) << ": ";
   while (node != nullptr)
   {
       cout << "(" << node->index << ", " << node->value << ") ";
       node = node->next;
   }
   cout << endl;

}

// Hauptmethode, die das Programm ausführt int main() {

   // Deklariert und initialisiert Arrays für die Knoten und Kanten
   Node nodes[] = { {0,"A"},{1,"B"},{2,"C"},{3,"D"},{4,"E"} };
   Edge edges[] = { {0,1},{0,2},{1,4},{2,3},{3,1},{4,3} };
   int numberOfNodes = sizeof(nodes) / sizeof(nodes[0]); // Ermittelt die Anzahl der Knoten
   int numberOfEdges = sizeof(edges) / sizeof(edges[0]); // Ermittelt die Anzahl der Kanten
   DirectedGraph directedGraph(nodes, edges, numberOfEdges, numberOfNodes); // Erzeugt den gerichteten Graphen mit den gegebenen Knoten und Kanten
   for (int i = 0; i < numberOfNodes; i++) // for-Schleife, die alle Knoten des Graphen durchläuft
   {
       Node* headNode = directedGraph.headNode[i];
       writeAdjacencyList(headNode, i); // Gibt die Adjazenzliste für den Knoten headNode aus
   }

} </syntaxhighlight>

Siehe auch

Kautz-Graph

Literatur

{{#invoke:Vorlage:Literatur|f}}
{{#invoke:Vorlage:Literatur|f}}
{{#invoke:Vorlage:Literatur|f}}
{{#invoke:Vorlage:Literatur|f}}

Einzelnachweise

{{#ifeq: s | p | | {{#if: 4156815-1 | |

}} }}Vorlage:Hinweisbaustein{{#ifeq: s | p | | {{#if: 4156815-1 | |

}} }}{{#ifeq:||{{#if: | [[Kategorie:Wikipedia:GND fehlt {{#invoke:Str|left|{{{GNDCheck}}}|7}}]] }}{{#if: | {{#if: | | }} }} }}{{#if: | {{#ifeq: 0 | 2 | | }} }}{{#if: | {{#ifeq: 0 | 2 | | }} }}{{#ifeq: s | p | {{#if: 4156815-1 | | {{#if: {{#statements:P227}} | | }} }} }}{{#ifeq: s | p | {{#if: 4156815-1 | {{#if: {{#invoke:Wikidata|pageId}} | {{#if: {{#statements:P227}} | | }} }} }} }}{{#ifeq: s | p | {{#if: | | {{#if: {{#statements:P244}} | | }} }} }}{{#ifeq: s | p | {{#if: | {{#if: {{#invoke:Wikidata|pageId}} | {{#if: {{#statements:P244}} | | }} }} }} }}{{#ifeq: s | p | {{#if: | | {{#if: {{#statements:P214}} | | }} }} }}{{#ifeq: s | p | {{#if: | {{#if: {{#invoke:Wikidata|pageId}} | {{#if: {{#statements:P214}} | | }} }} }} }}Vorlage:Wikidata-Registrierung