Prim impl - maps

Author: ivanmmarkovic

Ch07. Graphs and Graph Algorithms/prims algorithm/graph.py

@@ -1,59 +1,41 @@
-from vertex import Vertex
 from priorityqueue import PriorityQueue
+from vertex import Vertex
 
 class Graph:
     def __init__(self):
-        self.vertices: list = []
-        self.adjacencyList: dict = {}
-        self.prev: dict = {}
-
-    def addVertex(self, label: str, weight:int = float("inf")):
-        vertex: Vertex = Vertex(label, weight)
-        vertex.index = len(self.vertices)
-        self.vertices.append(vertex)
-        self.prev[label] = None
-        self.adjacencyList[label] = []
+        self.__vertices__: dict = {}
+        self.__prev__: dict = {}
+        self.__adjacency_map__: dict = {}
 
-    def addEdge(self, label1: str, label2: str, weight: int):
-        vertex: Vertex = Vertex(label2, weight)
-        index: int = self.findIndexByLabel(label2)
-        vertex.index = index
-        self.adjacencyList[label1].append(vertex)
+    def add_vertex(self, label: str):
+        self.__vertices__[label] = Vertex(label)
+        self.__prev__[label] = None
+        self.__adjacency_map__[label]: dict = {}
 
-        vertex = Vertex(label1, weight)
-        index: int = self.findIndexByLabel(label1)
-        vertex.index = index
-        self.adjacencyList[label2].append(vertex)
+    def add_edge(self, label1: str, label2: str, weight: int = float("inf")):
+        self.__adjacency_map__[label1][label2] = Vertex(label2, weight)
 
     def prims(self, label: str):
+        self.__vertices__[label].weight = 0
+        pq: PriorityQueue = PriorityQueue()
+        for label in self.__vertices__:
+            pq.insert(self.__vertices__[label])
+        
         result: str = ""
-        index: int = self.findIndexByLabel(label)
-        self.vertices[index].weight = 0
-        pq = PriorityQueue()
-        pq.buildHeap(self.vertices)
-        current: Vertex
-        while not pq.isEmpty():
-            current = pq.deleteMin()
-            print(current.label)
-            if self.prev[current.label] is not None:
-                result += self.prev[current.label] + " -> " + current.label + ", "
-            for neighbour in self.adjacencyList[current.label]:
-                if neighbour.weight < self.vertices[neighbour.index].weight:
-                    self.prev[self.vertices[neighbour.index].label] = current.label
-                    self.vertices[neighbour.index].weight = neighbour.weight
-                    pq.decreaseKey(self.vertices[neighbour.index].key)
+        while not pq.is_empty():
+            v: Vertex = pq.delete_min()
+            if self.__prev__[v.label] is not None:
+                result += self.__prev__[v.label] + " - " + v.label + ", "
+            for neighbour_label in self.__adjacency_map__[v.label]:
+                neighbour: Vertex = self.__adjacency_map__[v.label][neighbour_label]
+                vertex: Vertex = self.__vertices__[neighbour_label]
+                if neighbour.weight < vertex.weight:
+                    self.__prev__[neighbour_label] = v.label
+                    vertex.weight = neighbour.weight
+                    pq.decrease_key(vertex.key)
+
         print(result)
+    
+    
 
-    def findIndexByLabel(self, label: str)->int:
-        found: bool = False
-        count: int = 0
-        while count < len(self.vertices) and not found:
-            if self.vertices[count].label == label:
-                found = True
-            else:
-                count += 1
-        if found:
-            return count
-        else:
-            return None
-        
+    

Ch07. Graphs and Graph Algorithms/prims algorithm/main.py

@@ -1,23 +1,23 @@
 from graph import Graph
 
-graph = Graph()
+graph: Graph = Graph()
 
 g = Graph()
-g.addVertex("A")
-g.addVertex("B")
-g.addVertex("C")
-g.addVertex("D")
-g.addVertex("E")
-g.addVertex("F")
+g.add_vertex("A")
+g.add_vertex("B")
+g.add_vertex("C")
+g.add_vertex("D")
+g.add_vertex("E")
+g.add_vertex("F")
 
 
-g.addEdge("A", "B", 4)
-g.addEdge("A", "F", 2)
-g.addEdge("B", "C", 6)
-g.addEdge("F", "B", 3)
-g.addEdge("F", "C", 1)
-g.addEdge("F", "E", 4)
-g.addEdge("C", "D", 3)
-g.addEdge("D", "E", 2)
+g.add_edge("A", "B", 4)
+g.add_edge("A", "F", 2)
+g.add_edge("B", "C", 6)
+g.add_edge("F", "B", 3)
+g.add_edge("F", "C", 1)
+g.add_edge("F", "E", 4)
+g.add_edge("C", "D", 3)
+g.add_edge("D", "E", 2)
 
 g.prims("A")

Ch07. Graphs and Graph Algorithms/prims algorithm/priorityqueue.py

@@ -1,60 +1,63 @@
 from vertex import Vertex
 
 class PriorityQueue:
-    def __init__(self, size: int = 0):
-        self.heap: list = [None]
-        self.size = size
+    def __init__(self):
+        self.__queue__: list = [None]
+        self.__pointer__: int = 0
 
-    def isEmpty(self)->bool:
-        return self.size == 0
+    def is_empty(self) -> bool:
+        return self.__pointer__ == 0
 
     def insert(self, vertex: Vertex):
-        self.size += 1
-        vertex.key = self.size
-        self.heap.append(vertex)
-        self.percUp(self.size)
-
-    def percUp(self, index: int):
-        while index // 2 > 0:
-            if self.heap[index].weight < self.heap[index//2].weight:
-                self.heap[index], self.heap[index//2] = self.heap[index//2], self.heap[index]
-                self.heap[index].key = index
-                self.heap[index//2].key = index // 2
-            index = index // 2
-
-    def decreaseKey(self, index):
-        self.percUp(index)
-
-    def deleteMin(self)->Vertex:
-        if self.isEmpty():
-            return None
-        else:
-            tmp: Vertex = self.heap[1]
-            self.heap[1] = self.heap[self.size]
-            self.heap[1].key = 1
-            self.heap.pop()
-            self.size -= 1
-            self.percDown(1)
-            return tmp
-
-    def percDown(self, index: int):
-        while index * 2 <= self.size:
-            minIndex: int = self.getMinIndex(index)
-            if self.heap[index].weight > self.heap[minIndex].weight:
-                self.heap[index], self.heap[minIndex] = self.heap[minIndex], self.heap[index]
-                self.heap[index].key = index
-                self.heap[minIndex].key = minIndex 
-            index = minIndex
-
-    def getMinIndex(self, index: int):
-        if index * 2 + 1 > self.size:
+        self.__pointer__ += 1
+        self.__queue__.append(vertex)
+        vertex.key = self.__pointer__
+        self.__perc_up__(self.__pointer__)
+
+    def __perc_up__(self, pointer: int):
+        while pointer // 2 > 0:
+            if self.__queue__[pointer].weight < self.__queue__[pointer // 2].weight:
+                self.__queue__[pointer], self.__queue__[pointer // 2] = self.__queue__[pointer // 2], self.__queue__[pointer]
+                self.__queue__[pointer].key = pointer
+                self.__queue__[pointer // 2].key = pointer // 2
+            pointer = pointer // 2
+
+    def decrease_key(self, key: int):
+        self.__perc_up__(key)
+
+    def get_min(self) -> Vertex:
+        if self.is_empty():
+            raise Exception("Priority Queue is empty")
+        return self.__queue__[1]
+
+    def delete_min(self) -> Vertex:
+        if self.is_empty():
+            raise Exception("Priority Queue is empty")
+        min_vertex: Vertex = self.__queue__[1]
+        self.__queue__[1] = self.__queue__[self.__pointer__]
+        self.__queue__[1].key = 1
+        self.__pointer__ -= 1
+        self.__queue__.pop()
+        self.__perc_down__(1)
+        return min_vertex
+
+    def __perc_down__(self, index: int):
+        while index * 2 <= self.__pointer__:
+            min_index: int = self.__min_index__(index)
+            if self.__queue__[index].weight > self.__queue__[min_index].weight:
+                self.__queue__[index], self.__queue__[min_index] = self.__queue__[min_index], self.__queue__[index]
+                self.__queue__[index].key = index
+                self.__queue__[min_index].key = min_index
+            index = min_index
+
+    def __min_index__(self, index: int) -> int:
+        if index * 2 + 1 > self.__pointer__:
             return index * 2
         else:
-            if self.heap[index * 2].weight <= self.heap[index * 2 + 1].weight:
-                return  index * 2
+            if self.__queue__[index * 2].weight <= self.__queue__[index * 2 + 1].weight:
+                return index * 2
             else:
                 return index * 2 + 1
-    
-    def buildHeap(self, vertices: list):
-        for vertex in vertices:
-            self.insert(vertex)
+
+
+

Ch07. Graphs and Graph Algorithms/prims algorithm/vertex.py

@@ -1,7 +1,7 @@
 
 class Vertex:
-    def __init__(self, label: str = None, weight: int = None, index: int = None, key: int = None):
-        self.label = label
-        self.weight = weight
-        self.index = index
-        self.key = key
+    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
+