Finish implementation

But because I make the weight of an edge as the key of the dictionary
any graph with more than a single edge with the same weight will
yield wrong result.

Signed-off-by: Aditya Prasad <[email protected]>

Author: anantham

Kruskal's.py

@@ -136,7 +136,7 @@ def __iter__(self):
 #  values(weights) range from 0 to k.
 def counting_sort(weights,max_weight):
     # these k+1 counters are made here is used to know how many times each value in range(k+1) (0 to k) repeats
-    counter=[0]*(k+1)
+    counter=[0]*(max_weight+1)
     for i in weights:
         # if you encounter a particular number increment its respective counter
         counter[i] += 1
@@ -155,25 +155,137 @@ def counting_sort(weights,max_weight):
 # now we have a optimal sorting function in hand, lets sort the list of edges.
 # a dictionary with weights of an edge and the vertexes involved in that edge.
 vrwght={}
+# take every vertex in the graph
 for ver1 in the_graph:
-    print "ver1 = "
-    print ver1
+    # take every vertex ver1 is connected to = ver2
     for ver2 in ver1.getConnections():
+        # make the dictionary with the weights and the 2 vertex's involved with the edge (thier key)
         vrwght[ver1.connectedTo[ver2]]=[ver1.getId(),ver2.getId()]
 
+print "\nThe edges with thier unsorted weights are"
 print vrwght
-print vrwght.keys()
-print the_graph.getVertices()
-print the_graph.getVertices()
 
+temp_weights=vrwght.keys()
+counting_sort(temp_weights,max_weight)
+
+sorted_weights={}
+for weight in temp_weights:
+    sorted_weights[weight]=vrwght[weight]
+
+print "\nAfter sorting"
+print sorted_weights
+
+
+# Now step 2 : now we the smallest edge wrt to weight and add it to the MST,
+# IF the two nodes associated with the edge belong TO DIFFERENT sets.
+# What? well see kruskal's algo for finding the MST is simple,
+# we take the graph, remove all the edges and order them based on thier weight
+# now we replace all the removed edges back to the "graph" (which we just now plucked clean)
+# smallest first. Subject to the condition that adding a edge doesnt cause a CYCLE or LOOP
+# to develop, a tree cant have such loops we must avoid them.so we skip them
+# so this series of steps explains Kruskal's algorithm:
+"""
+1. Take all edges in an array and Sort that array (in an ascending order)
+2. Take the next (minimum edge), examine its end nodes:
+    a) If they belong to different sets, merge their sets and add that edge to the tree
+    b) Otherwise skip the edge
+3. Print the tree obtained.
+"""
+
+# 2. a) is the method used to check if adding a particular edge will cause a cycle,
+# Thus comes the UNION-FIND algorithm :
+# Many thanks to  David Eppstein of the University of California,
+# this is taken from PADS, a library of Python Algorithms and Data Structures
+class UnionFind:
+    """Union-find data structure.
+
+    Each unionFind instance X maintains a family of disjoint sets of
+    hashable objects, supporting the following two methods:
+
+FIND
+    - X[item] returns a name for the set containing the given item.
+      Each set is named by an arbitrarily-chosen one of its members; as
+      long as the set remains unchanged it will keep the same name. If
+      the item is not yet part of a set in X, a new singleton set is
+      created for it.
+
+UNION
+    - X.union(item1, item2, ...) merges the sets containing each item
+      into a single larger set.  If any item is not yet part of a set
+      in X, it is added to X as one of the members of the merged set.
+    """
 
-    
-
+    def __init__(self):
+        """Create a new empty union-find structure."""
+        self.weights = {}
+        self.parents = {}
+
+    def __getitem__(self, object):
+        """Find and return the name of the set containing the object."""
+
+        # check for previously unknown object
+        # if the object is not present in the dictionary make the object itself its own parent and set its weight as 1
+        if object not in self.parents:
+            self.parents[object] = object
+            self.weights[object] = 1
+            return object
+
+        # find path of objects leading to the root
+        path = [object]
+        root = self.parents[object]
+        while root != path[-1]:
+            path.append(root)
+            root = self.parents[root]
+
+        # compress the path and return
+        for ancestor in path:
+            self.parents[ancestor] = root
+        return root
+        
+    def __iter__(self):
+        """Iterate through all items ever found or unioned by this structure."""
+        return iter(self.parents)
+
+    def union(self, *objects):
+        """Find the sets containing the objects and merge them all."""
+        roots = [self[x] for x in objects]
+        heaviest = max([(self.weights[r],r) for r in roots])[1]
+        for r in roots:
+            if r != heaviest:
+                self.weights[heaviest] += self.weights[r]
+                self.parents[r] = heaviest
+
+MST={}
+# lets make a union-find instance - this calls init 
+X=UnionFind()
+
+# sets up the graph - make singleton sets for each vertex
+for vertex_key in the_graph.getVertices():
+    # get all the vertices set up, make them parents of themselfs, each in thier individual sets
+    # execute FIND for all the vertex's in the_graph
+    X[the_graph.getVertex(vertex_key)]
+
+# now the UNION.
+for weight in sorted_weights:
+    # here sorted_weights[weight] gives the set of 2 vertex's involved in the that edge
+    if(X[the_graph.getVertex(sorted_weights[weight][0])]==X[the_graph.getVertex(sorted_weights[weight][1])]):
+        # if both vertices have the same parent (name) then they are in the same set, so ignore this edge
+        pass
+    else:
+        # else as they belong to different sets we can ADD this edge to the MST (MST will be a subset of sorted_weights)
+        MST[weight]=sorted_weights[weight]
+        # and merge the sets these two vertices belong to thus we call union on them.
+        X.union(the_graph.getVertex(sorted_weights[weight][0]),the_graph.getVertex(sorted_weights[weight][1]))
+
+# thus we have the MST done
+
+print " \n\nIn the graph with these vertex's"
+print the_graph.getVertices()
 
+print "\n With these edges between the vertexes given above, we obtain a Minimal Spanning Tree\n"
+print MST
 
-            
-            
-            
+print "\n Please note this is a dictionary with  key as the weight of the edge and value as the key's of the two vertex's involved in this edge"