[Feature] Added Dijkstras Pathfinding algorithm for weighted directed graphs.

Author: exterkamp

README.md

@@ -36,6 +36,7 @@ $ coverage report -m
   * [2D Grid BFS](searches/breadth_first_search.py)
   * [Graph BFS](searches/breadth_first_search.py)
 * [Finding Duplicates](searches/find_duplicates.py)
+* [Dijkstra's Pathfinding](searches/dijkstras.py)
 
 ### Data Structures
 * [LRU Cache](structures/lru_cache.py)
@@ -56,6 +57,8 @@ $ coverage report -m
   * [Find Start of Cycle](structures/linked_list.py)
 * [Graph](structures/graph.py)
   * [Detect Cycle](structures/graph.py)
+  * [Directed](structures/graph.py)
+  * [Directed Weighted](structures/graph.py)
 * [Fenwick Tree](structures/fenwick_tree.py)
 
 ### Algorithms

searches/dijkstras.py

@@ -0,0 +1,42 @@
+from functools import reduce
+
+def dijkstras(weighted_graph,src,dst):
+
+    vertices = set()
+    dist = {}
+    prev = {}
+    
+    # add all vertices to set
+    for vertex in weighted_graph.vertices:
+        vertices.add(vertex)
+        dist[vertex] = float('inf')
+        prev[vertex] = None
+
+    dist[src] = 0
+
+    while vertices:
+        min_dist_node = min(list(filter(lambda x: x[0] in vertices,dist.items())),key=lambda x: x[1])[0]
+
+        if min_dist_node == dst:
+            break
+
+        vertices.remove(min_dist_node)
+
+        for neighbor in weighted_graph.vertices[min_dist_node].adjacent:
+
+            distance = weighted_graph.vertices[min_dist_node].adjacent[neighbor]
+
+            if distance < dist[neighbor]:
+                dist[neighbor] = distance
+                prev[neighbor] = min_dist_node
+
+    # trace back from dst
+    path = []
+    current = dst
+    while prev[current]:
+        path.append(current)
+        current = prev[current]
+    path.append(current)
+
+    return path[::-1]
+

structures/graph.py

@@ -111,4 +111,45 @@ def dfs(vertex):
                 dfs(i)
 
         return stack
-    
+
+class WeightedGraphNode():
+
+    def __init__(self, val):
+        self.val = val
+        self.adjacent = {}
+    
+    def __str__(self):
+        return str(self.val) + ' adjacent: ' + str([x for x in self.adjacent])
+
+    def add_adjacent(self, node, weight=0):
+        self.adjacent[node] = weight
+    
+    def remove_adjacent(self, node):
+        del self.adjacent[node]
+
+class WeightedGraph():
+
+    def __init__(self):
+        self.vertices = {}
+    
+    def __str__(self):
+        return ", ".join([node.__str__() for node in self.vertices.values()])
+    
+    def add_vertex(self, val):
+        vertex = WeightedGraphNode(val)
+        self.vertices[val] = vertex
+    
+    def add_edge(self, src, dst, weight=0):
+        if src not in self.vertices:
+            self.add_vertex(src)
+        if dst not in self.vertices:
+            self.add_vertex(dst)
+        self.vertices[src].add_adjacent(dst, weight)
+    
+    def remove_edge(self, src, dst):
+        if src not in self.vertices:
+            return
+        if dst not in self.vertices:
+            return
+        if dst in self.vertices[src].adjacent:
+            self.vertices[src].remove_adjacent(dst)

tests/test_dijkstras.py

@@ -0,0 +1,29 @@
+import unittest
+from searches.dijkstras import dijkstras
+from structures.graph import WeightedGraph
+
+class TestDijkstras(unittest.TestCase):
+
+    def test_basic_dij(self):
+        graph = WeightedGraph()
+
+        graph.add_edge('a','b',1)
+        graph.add_edge('a','c',4)
+        graph.add_edge('b','c',2)
+
+        self.assertEqual(['a','b','c'], dijkstras(graph,'a','c'))
+    
+    def test_advanced_dij(self):
+        graph = WeightedGraph()
+
+        graph.add_edge('1','2',7)
+        graph.add_edge('1','3',9)
+        graph.add_edge('1','6',14)
+        graph.add_edge('2','3',10)
+        graph.add_edge('2','4',15)
+        graph.add_edge('3','4',11)
+        graph.add_edge('3','6',2)
+        graph.add_edge('4','5',6)
+        graph.add_edge('6','5',9)
+
+        self.assertEqual(['1','3','6','5'], dijkstras(graph,'1','5'))

tests/test_weighted_graph.py

@@ -0,0 +1,49 @@
+import unittest
+from structures.graph import WeightedGraphNode, WeightedGraph
+
+class TestWeightedGraph(unittest.TestCase):
+
+    def test_add_vertex(self):
+
+        graph = WeightedGraph()
+
+        graph.add_vertex('a')
+        graph.add_vertex('b')
+        graph.add_vertex('c')
+
+        self.assertEqual(['a','b','c'], list(graph.vertices.keys()))
+    
+    def test_add_edge(self):
+
+        graph = WeightedGraph()
+
+        graph.add_edge('a','b',1)
+        graph.add_edge('a','c',3)
+        graph.add_edge('b','c',2)
+
+        self.assertEqual({'b':1,'c':3}, graph.vertices['a'].adjacent)
+
+        self.assertEqual({'c':2}, graph.vertices['b'].adjacent)
+
+    def test_remove_adjacent(self):
+
+        graph = WeightedGraph()
+
+        graph.add_edge('a','b',2)
+
+        graph.remove_edge('a','b')
+
+        graph.remove_edge('a','c')
+
+        graph.remove_edge('c','a')
+
+        self.assertEqual({}, graph.vertices['a'].adjacent)
+
+    def test_print_graph(self):
+        graph = WeightedGraph()
+
+        graph.add_edge('a','b',1)
+        graph.add_edge('a','c',3)
+        graph.add_edge('b','c',2)
+
+        self.assertEqual("a adjacent: ['b', 'c'], b adjacent: ['c'], c adjacent: []", graph.__str__())