graphs

Author: ivanmmarkovic

graphs/dijkstra/priority-queue-impl-adjacency-map/__pycache__/graph.cpython-38.pyc

@@ -0,0 +1,46 @@
+from vertex import Vertex
+from priorityqueue import PriorityQueue
+
+
+class Graph:
+    def __init__(self):
+        self._vertices: dict = {}
+        self._prev: dict = {}
+        self._adjacency_map: dict = {}
+
+    def add_vertex(self, label: str = None, weight: int = float("inf")):
+        self._vertices[label] = Vertex(label)
+        self._prev[label] = None
+        self._adjacency_map[label]: dict = {}
+
+    def add_edge(self, label1: str = None, label2: str = None, weight: int = float("inf")):
+        self._adjacency_map[label1][label2] = Vertex(label2, weight)
+
+    def dijkstra(self, label: str):
+        self._vertices[label].set_weight(0)
+        pq: PriorityQueue = PriorityQueue()
+        for vertex_label in self._vertices:
+            pq.insert(self._vertices[vertex_label])
+        while not pq.is_empty():
+            vertex: Vertex = pq.delete_min()
+            for neighbour_label in self._adjacency_map[vertex.get_label()]:
+                neighbour_from_adjacency_map: Vertex = self._adjacency_map[vertex.get_label()][neighbour_label]
+                neighbour_from_vertices: Vertex = self._vertices[neighbour_label]
+                if neighbour_from_vertices.get_weight() > \
+                        vertex.get_weight() + neighbour_from_adjacency_map.get_weight():
+                    neighbour_from_vertices.set_weight(vertex.get_weight() + neighbour_from_adjacency_map.get_weight())
+                    self._prev[neighbour_from_vertices.get_label()] = vertex.get_label()
+                    pq.decrease_key(neighbour_from_vertices.get_key())
+
+    def return_path(self, end_label: str = None) -> str:
+        if self._prev[end_label] is None:
+            return end_label
+        else:
+            return self.return_path(self._prev[end_label]) + " -> " + end_label
+
+
+
+
+
+
+

graphs/dijkstra/priority-queue-impl-adjacency-map/__pycache__/priorityqueue.cpython-38.pyc

@@ -0,0 +1,23 @@
+from graph import Graph
+
+
+graph: Graph = Graph()
+
+graph.add_vertex("START")
+graph.add_vertex("A")
+graph.add_vertex("C")
+graph.add_vertex("B")
+graph.add_vertex("D")
+graph.add_vertex("END")
+
+graph.add_edge("START", "A", 0)
+graph.add_edge("START", "C", 2)
+graph.add_edge("A", "B", 18)
+graph.add_edge("A", "D", 15)
+graph.add_edge("C", "B", 3)
+graph.add_edge("C", "D", 10)
+graph.add_edge("B", "END", 150)
+graph.add_edge("D", "END", 15)
+graph.dijkstra("START")
+
+print(graph.return_path("END"))

graphs/dijkstra/priority-queue-impl-adjacency-map/__pycache__/vertex.cpython-38.pyc

@@ -0,0 +1,59 @@
+from vertex import Vertex
+
+
+class PriorityQueue:
+    def __init__(self):
+        self._queue: list = [None]
+        self._pointer: int = 0
+
+    def is_empty(self) -> bool:
+        return self._pointer == 0
+
+    def insert(self, vertex: Vertex):
+        self._queue.append(vertex)
+        self._pointer += 1
+        vertex.set_key(self._pointer)
+        self._perc_up(self._pointer)
+
+    def _perc_up(self, index: int):
+        while index // 2 > 0:
+            if self._queue[index].get_weight() < self._queue[index // 2].get_weight():
+                self._queue[index], self._queue[index // 2] = self._queue[index // 2], self._queue[index]
+                self._queue[index].set_key(index)
+                self._queue[index // 2].set_key(index // 2)
+            index = index // 2
+
+    def decrease_key(self, key: int):
+        self._perc_up(key)
+
+    def delete_min(self) -> Vertex:
+        if self.is_empty():
+            raise Exception("Priority Queue is empty")
+        vertex_to_delete: Vertex = self._queue[1]
+        self._queue[1] = self._queue[self._pointer]
+        self._queue[1].set_key(1)
+        self._pointer -= 1
+        self._queue.pop()
+        self._perc_down(1)
+        return vertex_to_delete
+
+    def _perc_down(self, index: int):
+        while index * 2 <= self._pointer:
+            swap_index: int = self._find_swap_index(index)
+            if self._queue[index].get_weight() > self._queue[swap_index].get_weight():
+                self._queue[index], self._queue[swap_index] = self._queue[swap_index], self._queue[index]
+                self._queue[index].set_key(index)
+                self._queue[swap_index].set_key(swap_index)
+            index = swap_index
+
+    def _find_swap_index(self, index) -> int:
+        if index * 2 + 1 > self._pointer:
+            return index * 2
+        else:
+            if self._queue[index * 2].get_weight() <= self._queue[index * 2 + 1].get_weight():
+                return index * 2
+            else:
+                return index * 2 + 1
+
+
+

graphs/dijkstra/priority-queue-impl-adjacency-map/graph.py

@@ -0,0 +1,20 @@
+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
+
+    def get_label(self) -> str:
+        return self._label
+
+    def set_key(self, key: int):
+        self._key = key
+
+    def get_key(self) -> int:
+        return self._key
+
+    def set_weight(self, weight: int = float("inf")):
+        self._weight = weight
+
+    def get_weight(self) -> int:
+        return self._weight

graphs/dijkstra/priority-queue-impl-adjacency-map/main.py

@@ -0,0 +1,50 @@
+from vertex import Vertex
+from priorityqueue import PriorityQueue
+
+
+class Graph:
+    def __init__(self):
+        self._vertices: dict = {}
+        self._prev: dict = {}
+        self._adjacency_map: dict = {}
+
+    def add_vertex(self, label: str = None, weight: int = float("inf")):
+        self._vertices[label] = Vertex(label)
+        self._prev[label] = None
+        self._adjacency_map[label]: dict = {}
+
+    def add_edge(self, label1: str = None, label2: str = None, weight: int = float("inf")):
+        self._adjacency_map[label1][label2] = Vertex(label2, weight)
+        self._adjacency_map[label2][label1] = Vertex(label1, weight)
+
+    def prims(self, label: str):
+        result: str = ""
+        self._vertices[label].set_weight(0)
+        pq: PriorityQueue = PriorityQueue()
+        for vertex_label in self._vertices:
+            pq.insert(self._vertices[vertex_label])
+        while not pq.is_empty():
+            vertex: Vertex = pq.delete_min()
+            if self._prev[vertex.get_label()] is not None:
+                result += self._prev[vertex.get_label()] + " -> " + vertex.get_label() + ", "
+            for neighbour_label in self._adjacency_map[vertex.get_label()]:
+                neighbour_from_adjacency_map: Vertex = self._adjacency_map[vertex.get_label()][neighbour_label]
+                neighbour_from_vertices: Vertex = self._vertices[neighbour_label]
+                if neighbour_from_vertices.get_weight() > neighbour_from_adjacency_map.get_weight():
+                    neighbour_from_vertices.set_weight(neighbour_from_adjacency_map.get_weight())
+                    self._prev[neighbour_from_vertices.get_label()] = vertex.get_label()
+                    pq.decrease_key(neighbour_from_vertices.get_key())
+        print(result)
+
+    def return_path(self, end_label: str = None) -> str:
+        if self._prev[end_label] is None:
+            return end_label
+        else:
+            return self.return_path(self._prev[end_label]) + " -> " + end_label
+
+
+
+
+
+
+

graphs/dijkstra/priority-queue-impl-adjacency-map/priorityqueue.py

@@ -0,0 +1,23 @@
+from graph import Graph
+
+graph: Graph = Graph()
+
+g = Graph()
+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.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")

graphs/dijkstra/priority-queue-impl-adjacency-map/vertex.py

@@ -0,0 +1,59 @@
+from vertex import Vertex
+
+
+class PriorityQueue:
+    def __init__(self):
+        self._queue: list = [None]
+        self._pointer: int = 0
+
+    def is_empty(self) -> bool:
+        return self._pointer == 0
+
+    def insert(self, vertex: Vertex):
+        self._queue.append(vertex)
+        self._pointer += 1
+        vertex.set_key(self._pointer)
+        self._perc_up(self._pointer)
+
+    def _perc_up(self, index: int):
+        while index // 2 > 0:
+            if self._queue[index].get_weight() < self._queue[index // 2].get_weight():
+                self._queue[index], self._queue[index // 2] = self._queue[index // 2], self._queue[index]
+                self._queue[index].set_key(index)
+                self._queue[index // 2].set_key(index // 2)
+            index = index // 2
+
+    def decrease_key(self, key: int):
+        self._perc_up(key)
+
+    def delete_min(self) -> Vertex:
+        if self.is_empty():
+            raise Exception("Priority Queue is empty")
+        vertex_to_delete: Vertex = self._queue[1]
+        self._queue[1] = self._queue[self._pointer]
+        self._queue[1].set_key(1)
+        self._pointer -= 1
+        self._queue.pop()
+        self._perc_down(1)
+        return vertex_to_delete
+
+    def _perc_down(self, index: int):
+        while index * 2 <= self._pointer:
+            swap_index: int = self._find_swap_index(index)
+            if self._queue[index].get_weight() > self._queue[swap_index].get_weight():
+                self._queue[index], self._queue[swap_index] = self._queue[swap_index], self._queue[index]
+                self._queue[index].set_key(index)
+                self._queue[swap_index].set_key(swap_index)
+            index = swap_index
+
+    def _find_swap_index(self, index) -> int:
+        if index * 2 + 1 > self._pointer:
+            return index * 2
+        else:
+            if self._queue[index * 2].get_weight() <= self._queue[index * 2 + 1].get_weight():
+                return index * 2
+            else:
+                return index * 2 + 1
+
+
+