Use the bit array implementation and the hash table implementation to create two pairs of sets. The same groups ought to be used in both versions. Compare the key actions (union, intersection, difference, and isSubset) of each implementation using the Timing class, then give the real time difference.

Draw the Weighted Quick Union object on 0 through 10, that results from the following connect calls. Do not use path compression. Note that if we connect two sets of equal weight, by convention we make the set whose root has a smaller number the parent of the other. We use the convention that if an element is the root of the set its array value is the weight of the set negated. connect (0, 1); connect (2, 3); connect (9, 5); connect (5, 7); connect (7, 1); connect (4, 2); 1); connect (3,

Write a python code for #3

We discussed several Linked List Variations, each of which was more complex than the one preceding it, but that was able to do certain things asymptotically faster than the simpler variants could. This is one of many examples we'll see this quarter where we make a classic tradeoff in computing: using more memory (and, correspondingly, more complexity for managing what it's in it) in an effort to spend less time. While it's not always true that we can make things faster by using more memory, it's not at all uncommon to see these two things be on opposite sides of a tradeoff. One of the linked list variants we saw was a singly-linked list with head and tail pointers. Let's consider where this variant fell short and whether there are other ways to improve it besides what we saw. 1. Why isn't the presence of a tail pointer enough to allow us to remove the last node in the list in O(1) time? 2. Suppose that we added a third list-level pointer (i.e., outside of the nodes) called before Tail,…