Note that the trees are not necessarily binary trees:

Size: px

Start display at page:

Download "Note that the trees are not necessarily binary trees:"

Logan Ford
7 years ago
Views:

1 Trees ) Represent each set by a tree, where each element points to its parent and the root points back to itself. The representative of a set is the root. Note that the trees are not necessarily binary trees: MAKE-SET(x) just create a new tree with root x. Complexity: O(1) FIND-SET(x):: Complexity: O(depth of x) simply follow parent pointers back to the root of x UNION(x,y): just make the root of one of the trees point to the roo Complexity: (max{height(tree x ),height(tree y )}) 93

2 Worst-case sequence complexity for m operations: Lower Bound Just like for the linked list with back pointers but no size I.e., we can create a tree that is just one long chain with m/4 element How can we create this tree? using a combination of MAKE-SET and UNION operations. for i = 1 to m/4 do MAKE-SET(x i )for i = 1 to m/4-1 UNION(x 94

3 Creating this tree takes m/4 MAKE-SET operations and m/4 1 UNION operations. Now FIND-SET takes time (m). If we perform m/2 FIND-SET operations, we get a sequence whose total time is (m 2 ). Q: How do we know there is not a sequence of operations that takes longer than (m 2 )? same argument as for linked lists Q: How can we improve the trees data structure representation of disjoint sets? 95

4 Add path compression When performing FIND-SET(x), keep track of the nodes visited on the path from x to the root of the tree by using a stack or queue once the root is found, update the parent pointers of each node to poi Q: How does this affect the complexity of the FIND-SET operation? doubles it the first time, makes it constant the rest of the time Q: What is the complexity of a UNION(x,y) operation? depends on whether FIND-SET has already been called on one/both of x Q: Does the improvement in complexity of UNION and subsequent FIND-SET operations out-weigh the increase in cost of the initial FIND-SET? Q: How might we answer this? do amortized analysis we ll see this topic next. 96

5 Consider a sequence of operations including n MAKE-SET ops, at most n 1 UNIONs and f FIND-SET ops, the worst-case running time of a single operation in the sequence is: f log n ( log(1 + f/n) ) if f n (n + f log n) if f<n Q: Can we do better? Add union-by-rank and path compression. Q: What measure of trees matters the most? With trees, the measure that matters the most for the running time is the Recall union-by-weight for lists. For trees it makes more sense to relate heuristics to the height of a tree rather than the overall weight in the UNION operation. Define the rank of a tree to be an upper bound on the height of the tree. Note that the rank may not be equal to the height of the tree. We ll store the rank of a tree at it s root. 97

6 Operations MAKE-SET(x): Same as before, add rank(x)=0. UNION(x,y): We know rank(tree y ) and rank(tree x ). Which root of tree x and tree y becomes the new root? the node with higher rank is the new root What is the rank of the new tree? same as larger rank unless the two nodes have the same rank, pick FIND-SET: Nothing changes use path compression. Does not affect rank. This is the best disjoint set implementation. Q: How good is the worst-case sequence complexity? It is possible to prove that the worst-case time for a sequence of m operations, where there are n MAKE-SETs, is O(m log n). Q: What is log? It is the number of times that you need to apply log to n until the answer is 98

7 Example: n = 40 ) 5 < log 40 < 6 ) 2 < log log 40 < 3 ) 1 < log log log 40 < 2 ) 0 < log log log log 40 < 1 ) Back to Kruskal s Algorithm KRUSKAL-MST(G=(V,E),w:E->Z) A := {}; insert the edges into a priority queue Q; for each vertex v in V, MAKE-SET(v); while (Q not empty) e = EXTRACT-MIN(Q) \\e = (u,v); if FIND-SET(u) =/= FIND-SET(v) then UNION(u,v); A := A U {e}; end if end for END KRUSKAL-MST Q: If graph G has n vertices and is connected, then how many edges does G have? m>n 1 Q: Inserting the edges into a priority queue and extracting the min for each edge takes how long? m log m 99

8 Suppose that we implement the disjoint set ADT using linked lists with union-by-weight. (Remember, linked-lists have a pointer back to the representative element How many MAKE-SETs do we do? n Complexity? O(n) Q: How many FIND-SETs do we do? at most 2m-since we could visit the endpoints of an edge at most 2 times. Complexity? O(m) Q: How many UNIONs do we do? at most m Complexity? at most O(n log n) So the worst-case complexity of Kruskals is O(m log m + n + m + n log n). The bottleneck is the sorting (priority queue step). Therefore the complexity is O(m log m) 100

The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge,

The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge, cheapest first, we had to determine whether its two endpoints