kruskals-algorithm

I am looking for C++ Kruskal implementations to benchmark against my own... If you know a few good ones, please share! There's boost::kruskal_minimum_spanning_tree . Prim's algorithm is there too if you want to compare against that. 来源： https://stackoverflow.com/questions/4424512/kruskals-algorithm-in-c

The Kruskal's algorithm is the following: MST-KRUSKAL(G,w) 1. A={} 2. for each vertex v∈ G.V 3. MAKE-SET(v) 4. sort the edges of G.E into nondecreasing order by weight w 5. for each edge (u,v) ∈ G.E, taken in nondecreasing order by weight w 6. if FIND-SET(u)!=FIND-SET(v) 7. A=A U {(u,v)} 8. Union(u,v) 9. return A According to my textbook: Initializing the set A in line 1 takes O(1) time, and the time to sort the edges in line 4 is O(E lgE). The for loop of lines 5-8 performs O(E) FIND-SET and UNION operations on the disjoint-set forest. Along with the |V| MAKE-SET operations, these take a

Does the opposite of Kruskal's algorithm for minimum spanning tree work for it? I mean, choosing the max weight (edge) every step? Any other idea to find maximum spanning tree? systemkern Yes, it does. One method for computing the maximum weight spanning tree of a network G – due to Kruskal – can be summarized as follows. Sort the edges of G into decreasing order by weight. Let T be the set of edges comprising the maximum weight spanning tree. Set T = ∅. Add the first edge to T. Add the next edge to T if and only if it does not form a cycle in T. If there are no remaining edges exit and report

I was wondering when one should use Prim's algorithm and when Kruskal's to find the minimum spanning tree? They both have easy logics, same worst cases, and only difference is implementation which might involve a bit different data structures. So what is the deciding factor? Use Prim's algorithm when you have a graph with lots of edges. For a graph with V vertices E edges, Kruskal's algorithm runs in O(E log V) time and Prim's algorithm can run in O(E + V log V) amortized time, if you use a Fibonacci Heap . Prim's algorithm is significantly faster in the limit when you've got a really dense