Implementation of Kruskal's Minimimum Spanning Tree construction algorithm (#3)

* Add unionfind class for disjoint set datastructure
Implement kruskal's minimum spanning tree algorithm for sparse graph.

* Fix resulted MST as digrah representation
Add test code for splited minimum spanning tree construction algorithms

Author: goldragoon

core/pygraph/algorithms/minmax.py

@@ -31,35 +31,38 @@
 """
 Minimization and maximization algorithms.
 
-@sort: heuristic_search, minimal_spanning_tree, shortest_path,
-shortest_path_bellman_ford
+@sort: heuristic_search, minimal_spanning_tree_prim,
+minimal_spanning_tree_kruskal, shortest_path, shortest_path_bellman_ford
 """
 
 from pygraph.algorithms.utils import heappush, heappop
 from pygraph.classes.exceptions import NodeUnreachable
 from pygraph.classes.exceptions import NegativeWeightCycleError
 from pygraph.classes.digraph import digraph
+from pygraph.classes.unionfind import UnionFind
+import heapq
 import bisect
 
 # Minimal spanning tree
 
-def minimal_spanning_tree(graph, root=None):
+
+def minimal_spanning_tree_prim(graph, root=None, parallel=None):
     """
-    Minimal spanning tree.
+    Minimal spanning tree constructed with prim's algorithm.
 
     @attention: Minimal spanning tree is meaningful only for weighted graphs.
 
     @type  graph: graph
     @param graph: Graph.
-    
+
     @type  root: node
     @param root: Optional root node (will explore only root's connected component)
 
     @rtype:  dictionary
     @return: Generated spanning tree.
     """
     visited = []            # List for marking visited and non-visited nodes
-    spanning_tree = {}        # MInimal Spanning tree
+    spanning_tree = {}        # Minimal Spanning tree
 
     # Initialization
     if (root is not None):
@@ -68,11 +71,11 @@ def minimal_spanning_tree(graph, root=None):
         spanning_tree[root] = None
     else:
         nroot = 1
-    
+
     # Algorithm loop
     while (nroot is not None):
         ledge = _lightest_edge(graph, visited)
-        if (ledge == None):
+        if (ledge is None):
             if (root is not None):
                 break
             nroot = _first_unvisited(graph, visited)
@@ -81,11 +84,59 @@ def minimal_spanning_tree(graph, root=None):
             visited.append(nroot)
         else:
             spanning_tree[ledge[1]] = ledge[0]
+            spanning_tree[ledge[0]] = ledge[1]
             visited.append(ledge[1])
 
     return spanning_tree
 
 
+def minimal_spanning_tree_kruskal(graph, root=None, parallel=None):
+    """
+    Minimal spanning tree constructed with kruskal's algorithm.
+
+    @attention: Minimal spanning tree is meaningful only for weighted graphs.
+
+    @type  graph: graph
+    @param graph: Graph.
+
+    @type  root: node
+    @param root: Optional root node (will explore only root's connected component)
+
+    @rtype:  dictionary
+    @return: Generated spanning tree.
+    """
+
+    EDGE_WEIGHT = 0
+    EDGE_OBJ = 1
+
+    if root is not None:
+        # Will be implemented later
+        pass
+    else:
+        root = 0
+
+    spanning_tree = {}
+    edges = graph.edges()
+    num_edges = len(edges)
+    edges_heap = []
+
+    for edge in [(graph.edge_weight(edge), edge) for edge in edges]:
+        heapq.heappush(edges_heap, edge)
+    heapq.heapify(edges_heap)
+   
+    spanning_tree[root] = None
+    cycle_checker = UnionFind(num_edges)
+    for min_edge in range(num_edges):
+        min_elem = heapq.heappop(edges_heap)
+        min_edge = min_elem[EDGE_OBJ]
+        if not cycle_checker.find(min_edge[0], min_edge[1]):
+            cycle_checker.union(min_edge[0], min_edge[1])
+            spanning_tree[min_edge[1]] = min_edge[0]
+            spanning_tree[min_edge[0]] = min_edge[1]
+
+    return spanning_tree 
+
+
 def _first_unvisited(graph, visited):
     """
     Return first unvisited node.
@@ -138,7 +189,7 @@ def shortest_path(graph, source):
     algorithm.
     
     @attention: All weights must be nonnegative.
-    
+
     @see: shortest_path_bellman_ford
 
     @type  graph: graph, digraph

core/pygraph/classes/unionfind.py

@@ -0,0 +1,30 @@
+class UnionFind:
+    """
+	Weighted Union-Find with Path Compression
+    """
+
+    def __init__(self, n):
+        self._id = list(range(n))
+        self._sz = [1] * n
+
+    def _root(self, i):
+        j = i
+        while (j != self._id[j]):
+            self._id[j] = self._id[self._id[j]]
+            j = self._id[j]
+        return j
+
+    def find(self, p, q):
+        return self._root(p) == self._root(q)
+    
+    def union(self, p, q):
+        i = self._root(p)
+        j = self._root(q)
+        if i == j:
+            return
+        if (self._sz[i] < self._sz[j]):
+            self._id[i] = j
+            self._sz[j] += self._sz[i]
+        else:
+            self._id[j] = i
+            self._sz[i] += self._sz[j]

core/pygraph/mixins/labeling.py

@@ -39,7 +39,7 @@ class labeling( object ):
 
     def __init__(self):
         # Metadata bout edges
-        self.edge_properties = {}    # Mapping: Edge -> Dict mapping, lablel-> str, wt->num
+        self.edge_properties = {}    # Mapping: Edge -> Dict mapping, label-> str, wt->num
         self.edge_attr = {}          # Key value pairs: (Edge -> Attributes)
 
         # Metadata bout nodes
@@ -224,4 +224,4 @@ def nodes_eq():
                 if (not attrs_eq(self.node_attributes(node), other.node_attributes(node))): return False 
             return True
 
-        return nodes_eq() and edges_eq()
+        return nodes_eq() and edges_eq()

tests/unittests-minmax.py

@@ -34,8 +34,8 @@
 from pygraph.classes.digraph import digraph
 
 from pygraph.algorithms.searching import depth_first_search
-from pygraph.algorithms.minmax import minimal_spanning_tree,\
-shortest_path, heuristic_search, shortest_path_bellman_ford, maximum_flow, cut_tree
+from pygraph.algorithms.minmax import minimal_spanning_tree_kruskal,\
+minimal_spanning_tree_prim, shortest_path, heuristic_search, shortest_path_bellman_ford, maximum_flow, cut_tree
 from pygraph.algorithms.heuristics.chow import chow
 from pygraph.classes.exceptions import NegativeWeightCycleError
 
@@ -97,11 +97,31 @@ def generate_fixture_digraph_unconnected():
 
 # minimal spanning tree tests
 
-class test_minimal_spanning_tree(unittest.TestCase):
+class test_minimal_spanning_tree_kruskal(unittest.TestCase):
 
-    def test_minimal_spanning_tree_on_graph(self):
+    def test_minimal_spanning_tree_kruskal_on_graph(self):
         gr = testlib.new_graph(wt_range=(1,10))
-        mst = minimal_spanning_tree(gr, root=0)
+        mst = minimal_spanning_tree_kruskal(gr, root=0)
+        print(mst)
+        wt = tree_weight(gr, mst)
+        len_dfs = len(depth_first_search(gr, root=0)[0])
+        for each in mst:
+            if (mst[each] != None):
+                mst_copy = deepcopy(mst)
+                del(mst_copy[each])
+                for other in gr[each]:
+                     mst_copy[each] = other
+                     if (tree_weight(gr, mst_copy) < wt):
+                         gr2 = graph()
+                         add_spanning_tree(gr2, mst_copy)
+                         assert len(depth_first_search(gr2, root=0)[0]) < len_dfs
+
+
+class test_minimal_spanning_tree_prim(unittest.TestCase):
+
+    def test_minimal_spanning_tree_prim_on_graph(self):
+        gr = testlib.new_graph(wt_range=(1,10))
+        mst = minimal_spanning_tree_prim(gr, root=0)
         wt = tree_weight(gr, mst)
         len_dfs = len(depth_first_search(gr, root=0)[0])
         for each in mst:
@@ -116,6 +136,7 @@ def test_minimal_spanning_tree_on_graph(self):
                          assert len(depth_first_search(gr2, root=0)[0]) < len_dfs
 
 
+
 # shortest path tests
 
 class test_shortest_path(unittest.TestCase):