Question

Any help would be appreciated.

Answer 1

You can intersect any two sorted lists in linear time.

• get the in-order (left child, then parent data, then right child) iterators for both AVL trees.
• peek at the head of both iterators.
  • if one iterator is exhausted, return the result set.
  • if both elements are equal or the union is being computed, add their minimum to the result set.
  • pop the lowest (if the iterators are in ascending order) element. If both are equal, pop both

This runs in O(n1+n2) and is optimal for the union operation (where you are bound by the output size).

Alternatively, you can look at all elements of the smaller tree to see if they are present in the larger tree. This runs in O(n1 log n2).

---

This is the algorithm Google uses (or considered using) in their BigTable engine to find an intersection:

• Get iterators for all sources
• Start with pivot = null
• loop over all n iterators in sequence until any of them is exhausted.
  • find the smallest element larger than the pivot in this iterator.
  • if the element is the pivot
    • increment the count of the iterators the pivot is in
    • if this pivot is in all iterators, add the pivot to the result set.
  • else
    • reset the count of the iterators the pivot is in
    • use the found element as the new pivot.

To find an element or the next largest element in a binary tree iterator:

• start from the current element
• walk up until the current element is larger than the element being searched for or you are in the root
• walk down until you find the element or you can’t go to the left
• if the current element is smaller than the element being searched, return null (this iterator is exhausted)
• else return the current element

This decays to O(n1+n2) for similarly-sized sets that are perfectly mixed, and to O(n1 log n2) if the second tree is much bigger. If the range of a subtree in one tree does not intersect any node in the other tree / all other trees, then at most one element from this subtree is ever visited (its minimum). This is possibly the fastest algorithm available.