implemented krustal with relative unit test

Author: Michele De Vita

pygorithm/minimun_spanning_tree/__init__.py

@@ -0,0 +1,51 @@
+import copy
+
+
+def get_nodes(edges_weighted: list):
+    return set(sum((edge for edge, weight in edges_weighted), ()))
+
+
+def is_reversed(curr_edge, edge):
+    return curr_edge[0] == edge[1] and curr_edge[1] == edge[0]
+
+
+def has_cycle(edges_w):
+    edges_w += [((b, a), weight) for (a, b), weight in edges_w]
+    for edge, weight in edges_w:
+        if rec_cycle_detector(edge, edge, copy.deepcopy(edges_w), 1):
+            return True
+    return False
+
+
+def rec_cycle_detector(s_edge, curr_edge, edges_w, step=None):
+    if step > 2 and curr_edge[1] == s_edge[0]:
+        return True
+    neightbours = ((edge, weight) for edge, weight in edges_w if
+                   curr_edge[1] == edge[0] and not is_reversed(curr_edge, edge))
+    for neightbour in neightbours:
+        edges_w.remove(neightbour)
+        if rec_cycle_detector(s_edge, neightbour[0], edges_w, step + 1):
+            return True
+    return False
+
+
+def vertex_of(edge_w: tuple) -> set:
+    return set(edge_w[0])
+
+
+def minimum_spanning_tree(edges_weighted: list):
+    """
+    :param edges_weighted: A list of pair with first element the edge as tuple (e.g. (1,4))
+                                          and the weight as second element
+    :return:
+    """
+    edges_weighted.sort(key=lambda pair: pair[1])
+    edges_list = []
+    e_vertexes = set()
+    vertexes = get_nodes(edges_weighted)
+    while vertexes != e_vertexes:
+        edge_w = edges_weighted.pop(0)
+        if (len(edges_list) > 2 and not has_cycle(edges_list + [edge_w])) or len(edges_list) <= 2:
+            e_vertexes.update(vertex_of(edge_w))
+            edges_list.append(edge_w)
+    return edges_list

pygorithm/minimun_spanning_tree/kruskal.py

@@ -0,0 +1,37 @@
+import unittest
+
+from pygorithm.minimun_spanning_tree import kruskal
+
+
+class KruskalTest(unittest.TestCase):
+    def test_get_nodes(self):
+        edge_weighted = [((1, 3), 5), ((2, 4), 10), ((4, 1), 4)]
+        nodes = kruskal.get_nodes(edge_weighted)
+        expected = {1, 2, 3, 4}
+        self.assertEqual(nodes, expected)
+
+    def test_has_cycle(self):
+        edge_weighted = [((1, 3), 5), ((3, 4), 10), ((4, 1), 4)]
+        self.assertTrue(kruskal.has_cycle(edge_weighted))
+
+    def test_has_not_cycle(self):
+        edge_weighted = [((1, 3), 5), ((2, 4), 10), ((4, 1), 4)]
+        self.assertFalse(kruskal.has_cycle(edge_weighted))
+
+    def test_has_cycle_2(self):
+        edge_weighted = [((1, 3), 5), ((3, 2), 5), ((3, 4), 10), ((4, 1), 4)]
+        self.assertTrue(kruskal.has_cycle(edge_weighted))
+
+    def test_has_cycle_3(self):
+        edge_weighted = [((2, 3), 8), ((1, 4), 5), ((3, 5), 5), ((4, 6), 6), ((1, 2), 7), ((2, 5), 7)]
+        self.assertTrue(kruskal.has_cycle(edge_weighted))
+
+    def test_minimum_spanning_tree(self):
+        """
+        test taken from the example at the following link: https://en.wikipedia.org/wiki/Kruskal%27s_algorithm
+        """
+        edge_weighted = [((1, 2), 7), ((2, 3), 8), ((1, 4), 5), ((2, 4), 9),
+                         ((2, 5), 7), ((3, 5), 5), ((4, 6), 6), ((5, 6), 8),
+                         ((5, 7), 9), ((6, 7), 11), ((4, 5), 15)]
+        expected = [((1, 4), 5), ((3, 5), 5), ((4, 6), 6), ((1, 2), 7), ((2, 5), 7), ((5, 7), 9)]
+        self.assertEqual(kruskal.minimum_spanning_tree(edge_weighted), expected)