Prims algorithm

Author: ivanmmarkovic

graphs/minimum-spanning-tree/prims-algorithm/graph.py

@@ -0,0 +1,45 @@
+from vertex import Vertex
+from priorityqueue import PriorityQueue
+
+
+class Graph:
+    def __init__(self):
+        self._vertices: dict = {}
+        self._adjacency_map: dict = {}
+        self._prev: dict = {}
+
+    def add_vertex(self, label: str):
+        v: Vertex = Vertex(label)
+        self._vertices[label] = v
+        self._adjacency_map[label]: list = []
+        self._prev[label] = None
+
+    def add_edge(self, label1: str, label2: str, weight: int):
+        self._adjacency_map[label1].append(Vertex(label2, weight))
+        self._adjacency_map[label2].append(Vertex(label1, weight))
+
+    def prims(self, label: str):
+        result: str = ""
+        self._vertices[label].weight = 0
+        pq: PriorityQueue = PriorityQueue()
+        for label in self._vertices:
+            pq.insert(self._vertices[label])
+        while not pq.is_empty():
+            current: Vertex = pq.delete_min()
+            if self._prev[current.label] is not None:
+                result += self._prev[current.label] + " -> " + current.label + ", "
+            for neighbour in self._adjacency_map[current.label]:
+                v: Vertex = self._vertices[neighbour.label]
+                if neighbour.weight < v.weight:
+                    v.weight = neighbour.weight
+                    self._prev[v.label] = current.label
+                    pq.decrease_key(v.key)
+        print(result)
+
+
+
+
+
+
+
+

graphs/minimum-spanning-tree/prims-algorithm/main.py

@@ -0,0 +1,21 @@
+from graph import Graph
+
+
+graph: Graph = Graph()
+
+graph.add_vertex("a")
+graph.add_vertex("b")
+graph.add_vertex("f")
+graph.add_vertex("c")
+graph.add_vertex("d")
+graph.add_vertex("e")
+
+graph.add_edge("a", "b", 4)
+graph.add_edge("a", "f", 2)
+graph.add_edge("b", "c", 6)
+graph.add_edge("f", "b", 3)
+graph.add_edge("f", "c", 1)
+graph.add_edge("f", "e", 4)
+graph.add_edge("c", "d", 3)
+graph.add_edge("d", "e", 2)
+graph.prims("a")  # a -> f, f -> c, f -> b, c -> d, d -> e,

graphs/minimum-spanning-tree/prims-algorithm/priorityqueue.py

@@ -0,0 +1,56 @@
+from vertex import Vertex
+
+
+class PriorityQueue:
+    def __init__(self):
+        self.pq: list = [None]
+        self._pointer: int = 0
+
+    def is_empty(self) -> bool:
+        return self._pointer == 0
+
+    def insert(self, vertex: Vertex):
+        self.pq.append(vertex)
+        self._pointer += 1
+        vertex.key = self._pointer
+        self._perc_up(self._pointer)
+
+    def _perc_up(self, pointer: int):
+        while pointer // 2 > 0:
+            if self.pq[pointer // 2].weight > self.pq[pointer].weight:
+                self.pq[pointer // 2], self.pq[pointer] = self.pq[pointer], self.pq[pointer // 2]
+                self.pq[pointer // 2].key = pointer // 2
+                self.pq[pointer].key = pointer
+            pointer = pointer // 2
+
+    def decrease_key(self, pointer: int):
+        self._perc_up(pointer)
+
+    def delete_min(self) -> Vertex:
+        if self.is_empty():
+            raise Exception("Priority queue is empty")
+        v: Vertex = self.pq[1]
+        self.pq[1] = self.pq[self._pointer]
+        self.pq[1].key = 1
+        self.pq.pop()
+        self._pointer -= 1
+        self._perc_down(1)
+        return v
+
+    def _perc_down(self, pointer: int):
+        while pointer * 2 <= self._pointer:
+            min_index: int = self._find_swap_index(pointer)
+            if self.pq[pointer].weight > self.pq[min_index].weight:
+                self.pq[pointer], self.pq[min_index] = self.pq[min_index], self.pq[pointer]
+                self.pq[pointer].key = pointer
+                self.pq[min_index].key = min_index
+            pointer = min_index
+
+    def _find_swap_index(self, pointer: int) -> int:
+        if pointer * 2 + 1 > self._pointer:
+            return pointer * 2
+        else:
+            if self.pq[pointer * 2].weight <= self.pq[pointer * 2 + 1].weight:
+                return pointer * 2
+            else:
+                return pointer * 2 + 1

graphs/minimum-spanning-tree/prims-algorithm/vertex.py

@@ -0,0 +1,5 @@
+class Vertex:
+    def __init__(self, label: str = None, weight: int = float("inf"), key: int = None):
+        self.label: str = label
+        self.weight: int = weight
+        self.key: int = key