djikstra tests added

Author: aladdinpersson

.travis.yml

@@ -22,6 +22,8 @@ script:
      # Graph Theory Tests
      - python Algorithm_tests/graphtheory_tests/bellman_ford_test.py
      - python Algorithm_tests/graphtheory_tests/kahn_topological_ordering_test.py
+     - python Algorithm_tests/graphtheory_tests/Djikstra/djikstra_heap_test.py
+     - python Algorithm_tests/graphtheory_tests/Djikstra/djikstra_naive_test.py
 
      # Math tests
      - python Algorithm_tests/other_tests/test_binarysearch.py

Algorithm_tests/graphtheory_tests/Djikstra/djikstra_heap_test.py

@@ -0,0 +1,54 @@
+# Import folder where sorting algorithms
+import sys
+import unittest
+
+# For importing from different folders
+# OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
+sys.path.append('Algorithms/graphtheory/dijkstra/')
+
+# If run from local:
+#sys.path.append('../../../Algorithms/graphtheory/dijkstra/')
+
+from heapdijkstra import dijkstra
+
+class test_Dijkstra(unittest.TestCase):
+    def setUp(self):
+        self.G1 = {}
+        self.correct_path1 = []
+        self.correct_dist1 = float("inf")
+
+        self.G2 = {1:{2:1, 4:10}, 2:{3:15}, 3:{6:5}, 4:{5:1}, 5:{6:1}, 6: {}}
+        self.correct_path2 = [1,4,5,6]
+        self.correct_dist2 = 12
+
+        self.G3 = {1: {2: 1, 4: 10}, 2: {3: 15}, 3: {}, 4: {5:1}, 5: {}, 6: {}}
+        self.correct_path3 = []
+        self.correct_dist3 = float("inf")
+
+        self.G4 = {1: {2: 1, 4: 10}, 2: {3: 15}, 3: {6: 5}, 4: {5: 1}, 5: {6: 1}, 6: {}}
+        self.correct_path4 = [1, 4, 5]
+        self.correct_dist4 = 11
+
+    def test_emptygraph(self):
+        path_to_take, distances = dijkstra(self.G1, 0, 1)
+        self.assertEqual(distances[1], self.correct_dist1)
+        self.assertEqual(path_to_take, self.correct_path1)
+
+    def test_simplegraph(self):
+        path_to_take, distances = dijkstra(self.G2, 1, 6)
+        self.assertEqual(distances[6], self.correct_dist2)
+        self.assertEqual(path_to_take, self.correct_path2)
+
+    def test_no_path_exists(self):
+        path_to_take, distances = dijkstra(self.G3, 1, 6)
+        self.assertEqual(distances[6], self.correct_dist3)
+        self.assertEqual(path_to_take, self.correct_path3)
+
+    def test_not_endpoint(self):
+        path_to_take, distances = dijkstra(self.G4, 1, 5)
+        self.assertEqual(distances[5], self.correct_dist4)
+        self.assertEqual(path_to_take, self.correct_path4)
+
+if __name__ == '__main__':
+    print("Running Djikstra tests:")
+    unittest.main()

Algorithm_tests/graphtheory_tests/Djikstra/djikstra_naive_test.py

@@ -0,0 +1,55 @@
+# Import folder where sorting algorithms
+import sys
+import unittest
+
+# For importing from different folders
+# OBS: This is supposed to be done with automated testing, hence relative to folder we want to import from
+sys.path.append('Algorithms/graphtheory/dijkstra/')
+
+# If run from local:
+#sys.path.append('../../../Algorithms/graphtheory/dijkstra/')
+
+from dijkstra import dijkstra
+
+class test_Dijkstra(unittest.TestCase):
+    def setUp(self):
+        self.G1 = {}
+        self.correct_path1 = []
+        self.correct_dist1 = float("inf")
+
+        self.G2 = {1:{2:1, 4:10}, 2:{3:15}, 3:{6:5}, 4:{5:1}, 5:{6:1}, 6: {}}
+        self.correct_path2 = [1,4,5,6]
+        self.correct_dist2 = 12
+
+        self.G3 = {1: {2: 1, 4: 10}, 2: {3: 15}, 3: {}, 4: {5:1}, 5: {}, 6: {}}
+        self.correct_path3 = []
+        self.correct_dist3 = float("inf")
+
+        self.G4 = {1: {2: 1, 4: 10}, 2: {3: 15}, 3: {6: 5}, 4: {5: 1}, 5: {6: 1}, 6: {}}
+        self.correct_path4 = [1, 4, 5]
+        self.correct_dist4 = 11
+
+    def test_emptygraph(self):
+        path_to_take, distance = dijkstra(self.G1, 0, 1)
+        self.assertEqual(distance, self.correct_dist1)
+        self.assertEqual(path_to_take, self.correct_path1)
+
+    def test_simplegraph(self):
+        path_to_take, distance = dijkstra(self.G2, 1, 6)
+        self.assertEqual(distance, self.correct_dist2)
+        self.assertEqual(path_to_take, self.correct_path2)
+
+    def test_no_path_exists(self):
+        path_to_take, distance = dijkstra(self.G3, 1, 6)
+        self.assertEqual(distance, self.correct_dist3)
+        self.assertEqual(path_to_take, self.correct_path3)
+
+    def test_not_endpoint(self):
+        path_to_take, distance = dijkstra(self.G4, 1, 5)
+        self.assertEqual(distance, self.correct_dist4)
+        self.assertEqual(path_to_take, self.correct_path4)
+
+
+if __name__ == '__main__':
+    print("Running Djikstra tests:")
+    unittest.main()

Algorithms/graphtheory/dijkstra/__pycache__/dijkstra.cpython-37.pyc

@@ -1,5 +1,10 @@
-# Dijkstra's algorithm for finding the shortest path in a graph
-# Programmed 2019-01-28 <aladdin.persson at hotmail dot com>
+'''
+Dijkstra's algorithm for finding the shortest path in a graph
+
+Programmed by Aladdin Persson <aladdin.persson at hotmail dot com>
+    2019-01-28 Initial programming
+    2020-03-28 Cleaned up code
+'''
 
 def make_graph(file):
     try:
@@ -9,16 +14,16 @@ def make_graph(file):
 
     line_list = f.readlines()
 
-    # Found on mukeshmithrakumar github, thought this was clean..
-    # populate the graph using data from the text file via dictionary comprehensions
     G = {int(line.split()[0]): {(int(tup.split(',')[0])): int(tup.split(',')[1])
                                 for tup in line.split()[1:] if tup} for line in line_list if line}
 
     f.close()
     return G
 
-
 def dijkstra(G, start, end):
+    if start not in G or end not in G:
+        return [], float('inf')
+
     shortest_distance = {}
     predecessor = {}
     unseenNodes = G
@@ -34,7 +39,6 @@ def dijkstra(G, start, end):
     while unseenNodes:
         minNode = None
 
-        # priority-queue? -> Hittar bästa noden hittils
         for node in unseenNodes:
             if minNode is None:
                 minNode = node
@@ -49,32 +53,32 @@ def dijkstra(G, start, end):
 
         unseenNodes.pop(minNode)
 
-    print("pred")
-    print(predecessor)
+    # Find path from start node s to end node t
     currentNode = end
 
     while currentNode != start:
         try:
             path.insert(0, currentNode)
             currentNode = predecessor[currentNode]
         except KeyError:
-            print('Path not reachable')
-            break
+            return [], float('inf')
+
     path.insert(0,start)
 
-    return path, shortest_distance[end]
 
+    return path, shortest_distance[end]
 
 
+if __name__ == '__main__':
+    #G = make_graph('dijkstraData.txt')
 
-#G = make_graph('dijkstraData.txt')
+    G =  {1:{2:10, 3:20},
+          2:{4:40},
+          3:{4:5},
+          4:{}}
 
-G =  {1:{2:10, 3:20},
-      2:{4:40},
-      3:{4:5},
-      4:{}}
-print(f'Current graph is: {G}')
-path, shortest = dijkstra(G, 1, 4)
+    print(f'Current graph is: {G}')
+    path, shortest = dijkstra(G, 1, 4)
 
-print(path)
-print(shortest)
+    print(path)
+    print(shortest)

Algorithms/graphtheory/dijkstra/__pycache__/heapdijkstra.cpython-37.pyc

@@ -1,8 +1,12 @@
-# Dijkstra's algorithm for finding the shortest path.
-# Improved version with the usage of heaps.
+'''
+Dijkstra's algorithm for finding the shortest path.
+Improved version with the usage of heaps.
 
-# Programmed by Aladdin Persson <aladdin.persson at hotmail dot com>
-#   2019-02-15 Initial coding
+Programmed by Aladdin Persson <aladdin.persson at hotmail dot com>
+  2019-02-15 Initial coding
+  2020-03-28 Small code changes, fixed for edge cases not covered
+
+'''
 
 import heapq
 
@@ -14,14 +18,16 @@ def make_graph(file):
 
     line_list = f.readlines()
 
-    # Kinda messy.
-    # populate the graph using data from the text file via dictionary comprehensions
+    # Kinda messy graph loading
     G = {int(line.split()[0]): {(int(tup.split(',')[0])): int(tup.split(',')[1])
                                 for tup in line.split()[1:] if tup} for line in line_list if line}
     f.close()
     return G
 
 def dijkstra(G, start, end=None):
+    if start not in G or (end != None and end not in G):
+        return [], {end:float('inf')}
+
     distance, visited, history, heap, path = {}, {}, {}, [], []
 
     for node in G.keys():
@@ -48,19 +54,27 @@ def dijkstra(G, start, end=None):
             try:
                 path.insert(0, current_node)
                 current_node = history[current_node]
+
             except KeyError:
-                print('Path not reachable')
-                break
+                return [], distance
 
         path.insert(0, start)
 
-    return distance, path
+    return path, distance
 
 
 if __name__ == '__main__':
-    start, end = 1, 160
-    print(f'Goal is to find the path from node {start} to node {end}')
-    G = make_graph('dijkstraData.txt')
-
-    dist, path = dijkstra(G, start, end)
-    print(f'Path found: {path}')
+    # start, end = 1, 160
+    # print(f'Goal is to find the path from node {start} to node {end}')
+    # G = make_graph('dijkstraData.txt')
+
+    G = {1: {2: 10, 3: 20},
+         2: {4: 40},
+         3: {4: 5},
+         4: {}}
+    start=1
+    end=2
+
+    path, dist = dijkstra(G, start, end)
+    print(f'Path found: {path}')
+    print(dist)

Algorithms/graphtheory/dijkstra/djikstra.py renamed to Algorithms/graphtheory/dijkstra/dijkstra.py

@@ -15,8 +15,8 @@ Whenever I face an interesting problem I document the algorithm that I learned t
 * :white_check_mark: [Kahns Topological Sort](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/kahns-toposort/kahns.py) **- O(n + m)**
 * :white_check_mark: [Bellman-Ford Shortest Path](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/bellman-ford/bellman_ford.py) **-O(mn)**
 * :small_red_triangle: [Floyd-Warshall Shortest Path](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/floyd-warshall/floyd-warshall.py) **- O(n<sup>3</sup>)**
-* :small_red_triangle: [Dijkstra Shortest Path](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/dijkstra/djikstra.py) **- Naive implementation**
-* :small_red_triangle: [Dijkstra Shortest Path](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/dijkstra/heapdijkstra.py) **O(mlog(n)) - Heap implementation**
+* :white_check_mark: [Dijkstra Shortest Path](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/dijkstra/djikstra.py) **- Naive implementation**
+* :white_check_mark: [Dijkstra Shortest Path](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/dijkstra/heapdijkstra.py) **O(mlog(n)) - Heap implementation**
 * :small_red_triangle: [Karger's Minimum cut](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/kargers/kargermincut.py)
 * :small_red_triangle: [Prim's Algorithm](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/prims/prims_algorithm.py) **- Naive implementation**
 * :small_red_triangle: [Prim's Algorithm](https://github.com/AladdinPerzon/Algorithms-Collection-Python/blob/master/Algorithms/graphtheory/prims/primheap.py) **- mlog(n)**