Über die Suche in Baum- und Graphenstrukturen

Einführung

In diesem Artikel werden die Baumstruktur (Tree) und die Graphenstruktur (Graph), die als Datenstrukturen in der Informatik eine sehr wichtige Rolle spielen, im Detail erklärt, von ihren grundlegenden Konzepten bis hin zu Suchalgorithmen.

Im Bereich der Datenstrukturen und Algorithmen sind dies unvermeidliche Themen. Insbesondere die Tiefensuche (DFS), die Breitensuche (BFS) und der Dijkstra-Algorithmus (Dijkstra’s Algorithm) zur Lösung des Kürzeste-Wege-Problems treten in Programmierwettbewerben und in der Praxis häufig auf.

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

1. Grundlagen der Baumstruktur (Tree)

Die Baumstruktur ist eine Datenstruktur, die sich zur Darstellung von Daten mit hierarchischen Beziehungen eignet. Sie wird in verschiedenen Situationen verwendet, wie z. B. in Dateisystemen, Organigrammen, HTML-DOM-Bäumen usw.

Eine Baumstruktur besteht aus den folgenden Elementen:

• Knoten (Node): Das Element, das Daten enthält
• Kante (Edge): Die Linie, die die Knoten verbindet
• Wurzelknoten (Root Node): Der Knoten ganz oben im Baum. Es ist ein Knoten ohne Eltern.
• Blattknoten (Leaf Node): Ein Knoten ohne Kinder.

  graph TD
  "Root" --> "NodeA"
  "Root" --> "NodeB"
  "NodeA" --> "Leaf1"
  "NodeA" --> "Leaf2"
  "NodeB" --> "Leaf3"

Als Grundlage für die Suche in Baumstrukturen gibt es die Tiefensuche (DFS) und die Breitensuche (BFS).

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

2. Tiefensuche (DFS: Depth-First Search)

Die Tiefensuche ist ein Algorithmus, der an einem bestimmten Knoten beginnt, so tief wie möglich vordringt und bei einer Sackgasse zum vorherigen Knoten zurückkehrt, um die Suche fortzusetzen. Durch die Verwendung rekursiver Funktionen kann er sehr einfach implementiert werden. Manchmal wird auch eine Datenstruktur namens Stapel (Stack) verwendet.

Python-Implementierungsbeispiel für DFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

def dfs_tree(node):
    if node is None:
        return
    print(f"Besuche {node.value}")
    for child in node.children:
        dfs_tree(child)

# Baum aufbauen
root = TreeNode("Root")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("DFS-Durchlauf:")
dfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

3. Breitensuche (BFS: Breadth-First Search)

Die Breitensuche ist ein Algorithmus, der beim Wurzelknoten beginnt, alle Knoten auf derselben Tiefe durchsucht, bevor er zu den Knoten der nächsten Tiefe übergeht. Er verwendet eine Datenstruktur namens Warteschlange (Queue). Er wird häufig verwendet, um den kürzesten Weg zu finden.

Python-Implementierungsbeispiel für BFS in einer Baumstruktur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from collections import deque

def bfs_tree(root):
    if root is None:
        return
    queue = deque([root])
    while queue:
        current = queue.popleft()
        print(f"Besuche {current.value}")
        for child in current.children:
            queue.append(child)

print("BFS-Durchlauf:")
bfs_tree(root)

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

4. Grundlagen der Graphenstruktur (Graph)

Eine Graphenstruktur besteht aus einer Menge von Knoten (Ecken: Vertex) und Kanten (Linien: Edge). Eine Baumstruktur ist auch eine Art von Graph (ein ungerichteter Graph ohne Zyklen oder ein gerichteter Graph), aber ein allgemeiner Graph kann Zyklen (Cycle) haben und auch mehrere Eltern haben.

Es gibt folgende Arten von Graphen:

• Ungerichteter Graph (Undirected Graph): Ein Graph ohne Richtung an den Kanten
• Gerichteter Graph (Directed Graph): Ein Graph mit Richtung an den Kanten
• Gewichteter Graph (Weighted Graph): Ein Graph, bei dem den Kanten Gewichte (Kosten) zugewiesen sind

  graph LR
  "A" -- "5" --> "B"
  "A" -- "2" --> "C"
  "B" -- "1" --> "D"
  "C" -- "8" --> "D"
  "C" -- "4" --> "E"
  "D" -- "3" --> "E"

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")

5. Dijkstra-Algorithmus (Dijkstra’s Algorithm)

Der Dijkstra-Algorithmus ist ein Algorithmus, um in einem gewichteten Graphen den kürzesten Weg von einem Startknoten zu allen anderen Knoten zu finden. Die Kantengewichte müssen jedoch nicht-negativ (0 oder größer) sein.

Durch die Verwendung einer Vorrangwarteschlange (Priority Queue) kann die Suche effizient durchgeführt werden. Als mathematischer Ausdruck: Sei $ d(v) $ die kürzeste Entfernung vom Startpunkt zum Knoten $ v $. Für das Gewicht $ w(u, v) $ der Kante $ (u, v) $ wird aktualisiert: $ d(v) = \min(d(v), d(u) + w(u, v)) $. Als mathematische Formel erfüllt dies die Eigenschaft $ d(v) \le d(u) + w(u, v) $. Hierbei wird der Weg gewählt, bei dem $ \text{Kosten} $ minimal sind.

Python-Implementierungsbeispiel für den Dijkstra-Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import heapq

def dijkstra(graph, start):
    # Kürzeste Distanzen mit Unendlich initialisieren
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)

        if current_distance > distances[current_node]:
            continue

        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# Graphdefinition (Adjazenzlistenformat)
graph = {
    'A': {'B': 5, 'C': 2},
    'B': {'D': 1},
    'C': {'D': 8, 'E': 4},
    'D': {'E': 3},
    'E': {}
}

start_node = 'A'
shortest_paths = dijkstra(graph, start_node)
print(f"Kürzeste Wege von {start_node}: {shortest_paths}")