All right so QuickFind is too slow for huge problems. So, how are we going to do
better? Our first attempt is an alternative called, Quick-union. This is
so called lazy approach to algorithm design where we try to avoid doing work
until we have to. It uses the same data structure or array ID with size M but now
it has a different interpretation. We are going to think of that array as
representing a set of trees that's called a forest as depicted at right. So, each
entry in the array is going to contain a reference to its parent in the tree. So,
for example, 3's parent is four, 4's parent is nine. So 3's entry is four and
4's entry is nine in the array. Now each entry in the array has associated with it
a root. That's the root of its tree. Elements that are all by themselves in
just, in their own connected component, point to themselves, so one points to
itself but also nine points to itself. It's the root of the tree, containing two,
four and three. So, from this data structure we can associate with each item
a root, which is representative, say, of it's connected component. So that's the
root of three is nine, going up that root. Now, once we can calculate these roots,
then we can implement the find operation just by checking whether the two items
that we're supposed to check with are connective where they have the same root.
That's equivalent to saying, are they in the same connective component? So that's
some work, going to find the roots of each item but the union operation is very easy.
To merge components containing two different items. Two items that are in
different components. All we do is set the ID of P's route to the ID of Q's route.
Let's make P's tree point to Q. So in this case, we would change the entry of nine to
be six to merge three and five. The components containing three and five. And
with just changing one value in the array we get the two large components emerged
together. That's the Quick-union algorithm. Because a union operation only
involves changing one entry in the array. Find operation requires a little more
work. So let's look at the Implementation, a demo of that one in operation first. So
again we, we start out the same way but now the idea array entry really means that
every one of these things is a little tree where the one node each everyone pointing
to itself. It's the root of it's own tree so now if we have to put four and three in
the same component, then all we do is we take the root, of the component containing
the first item and make that a child of the root of the component, component
containing the second item. In this case we just make four as parent three. So now
three and eight. So again, we take the first item and make it a child of the root
of the tree containing the second item. So now three, four, and eight are in the same
component. Six and five six goes below five. Nine and four, So now four is the
root of the tree containing four is eight. And the root of tree containing nine is
nine. And so we make nine a child of eight. Two and one, that's an easy one.
Now if we get our, our eight and nine connected, we just checked that they have
the same root and they both have the same root eight and so they're connected. Five
and four 4's root is eight. 5's root is five. They're different. They're not
connected. Five and zero. Five goes to be a child of zero. Seven and two seven goes
to be a child of 2's root which is one. Six and one. 6's route is zero 1's its own
route, so zero becomes a child of one. Each one of these union operations just
involves changing one entry in the array. And finally, seven and three. So seven's
root is one, three's root is eight, one becomes a child of eight. Okay and now we
have one connected component with all the items together. Alright, so now let's look
at the code for implementing Quick-union. The constructor is the same as the other
one. We create the array and then set each element to be it's own root. Now we have a
private method that implements this process of finding the root by chasing
parent pointers until we get to the point where I is equal to ID of I, and if it's
not equal, we just move I up one level in the tree, set I equals ID of I and return
it. So starting at any node, you just follow ID equals ID of I until they're
equal and then you're at a root and that's a private method that we can use to
implement the find operation or the connected operation. You just find the
root of P and the root of Q and if you check if they're equal. And then the union
operation is simply find the two roots I and then set the idea the first one could
be the second one. Actually less code than for Quick Find, no fore loops. There's
this one wild loop that we have to worry about a little bit. But that's a quick and
elegant implementation of code to solve the dynamic connectivity problem called
Quick-union. So now we're going to have to look at can this code be effective for
large problems? Well unfortunately Quick-union is faster but it's also too
slow. And it's a little different kind of too slow then for Quick Find, there's
times when it could be fast, but there's also times when it could be too slow. And
the defect for Quick-union is that the trees can get too tall. Which would mean
that the find operation would be too expensive. You could wind up with a long
skinny tree. Of each object just pointing to next and then to do a find operation
for object at the bottom would involve going all the way through the tree.
Costing involving in the ray axises just to do the find operation and that's going
to be too slow if you have a lot of operations.
