Tentang Pencarian Struktur Pohon dan Struktur Graf

Pendahuluan

Dalam artikel ini, kami akan menjelaskan secara detail tentang struktur pohon (Tree) dan struktur graf (Graph), yang merupakan struktur data yang memainkan peran sangat penting dalam ilmu komputer, mulai dari konsep dasar hingga algoritma pencarian.

Dalam bidang struktur data dan algoritma, ini adalah tema yang tidak dapat dihindari. Khususnya pencarian mendalam pertama (DFS), pencarian melebar pertama (BFS), dan algoritma Dijkstra (Dijkstra’s Algorithm) untuk memecahkan masalah jalur terpendek sering muncul dalam kontes pemrograman dan praktik di lapangan.

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

1. Dasar-dasar Struktur Pohon (Tree)

Struktur pohon adalah struktur data yang cocok untuk merepresentasikan data yang memiliki hubungan hierarkis. Ini digunakan dalam berbagai situasi seperti sistem file, bagan organisasi, dan pohon DOM HTML.

Struktur pohon terdiri dari elemen-elemen berikut:

• Simpul (Node): Elemen yang menyimpan data
• Sisi (Edge): Garis yang menghubungkan antar simpul
• Simpul Akar (Root Node): Simpul yang berada di bagian paling atas dari pohon. Ini adalah simpul yang tidak memiliki induk.
• Simpul Daun (Leaf Node): Ini adalah simpul yang tidak memiliki anak.

  graph TD
  "Akar" --> "SimpulA"
  "Akar" --> "SimpulB"
  "SimpulA" --> "Daun1"
  "SimpulA" --> "Daun2"
  "SimpulB" --> "Daun3"

Sebagai dasar pencarian dalam struktur pohon, terdapat pencarian mendalam pertama (DFS) dan pencarian melebar pertama (BFS).

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

2. Pencarian Mendalam Pertama (DFS: Depth-First Search)

Pencarian mendalam pertama adalah algoritma yang dimulai dari suatu simpul, bergerak sedalam mungkin, dan ketika mencapai jalan buntu, ia akan kembali ke simpul sebelumnya dan melanjutkan pencarian. Dengan menggunakan fungsi rekursif, ini dapat diimplementasikan dengan sangat sederhana. Terkadang ini juga memanfaatkan struktur data yang disebut tumpukan (Stack).

Contoh Implementasi Python dari DFS pada Struktur Pohon

 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"Mengunjungi {node.value}")
    for child in node.children:
        dfs_tree(child)

# Membangun pohon
root = TreeNode("Akar")
node_a = TreeNode("A")
node_b = TreeNode("B")
root.children.extend([node_a, node_b])
node_a.children.extend([TreeNode("C"), TreeNode("D")])

print("Penelusuran DFS:")
dfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

3. Pencarian Melebar Pertama (BFS: Breadth-First Search)

Pencarian melebar pertama adalah algoritma yang dimulai dari simpul akar, menjelajahi semua simpul pada kedalaman yang sama sebelum melanjutkan ke simpul pada kedalaman berikutnya. Ini memanfaatkan struktur data yang disebut antrean (Queue). Ini sering digunakan saat mencari jalur terpendek dan sebagainya.

Contoh Implementasi Python dari BFS pada Struktur Pohon

 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"Mengunjungi {current.value}")
        for child in current.children:
            queue.append(child)

print("Penelusuran BFS:")
bfs_tree(root)

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

4. Dasar-dasar Struktur Graf (Graph)

Struktur graf terdiri dari kumpulan simpul (Vertex) dan sisi (Edge). Struktur pohon juga merupakan salah satu jenis graf (graf tak berarah tanpa siklus, atau graf berarah), tetapi graf pada umumnya dapat memiliki siklus (Cycle) dan memungkinkan adanya banyak induk.

Terdapat jenis-jenis graf berikut:

• Graf Tak Berarah (Undirected Graph): Graf yang sisi-sisinya tidak memiliki arah
• Graf Berarah (Directed Graph): Graf yang sisi-sisinya memiliki arah
• Graf Berbobot (Weighted Graph): Graf yang sisi-sisinya memiliki bobot (biaya)

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

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")

5. Algoritma Dijkstra (Dijkstra’s Algorithm)

Algoritma Dijkstra adalah algoritma untuk mencari jalur terpendek dari suatu titik awal ke semua titik (simpul) lainnya dalam graf berbobot. Namun, bobot dari sisi harus non-negatif (0 atau lebih).

Dengan menggunakan antrean prioritas (Priority Queue), penelusuran dapat dilakukan secara efisien. Dalam representasi matematis, jika $ d(v) $ adalah jarak terpendek dari titik awal ke simpul $ v $, maka untuk bobot $ w(u, v) $ dari sisi $ (u, v) $, nilai tersebut diperbarui sebagai $ d(v) = \min(d(v), d(u) + w(u, v)) $. Secara matematis, hal ini memenuhi properti $ d(v) \le d(u) + w(u, v) $. Di sini, kita memilih jalur dengan $ \text{biaya} $ terkecil.

Contoh Implementasi Python dari Algoritma Dijkstra

 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):
    # Menginisialisasi jarak terpendek dengan tak terhingga
    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

# Definisi graf (format daftar ketetanggaan)
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"Jalur terpendek dari {start_node}: {shortest_paths}")