Question

Need to define a seek(u,v) function, where u is the new node within the tree (the node where I want to start searching), and v is the number of descendants below the new node, and this function would return index of highest key value. The tree doesn’t have a be a BST, there can be nodes with many many children. Example:

input:
5             // tree with 5 nodes
1 3 5 2 7     // the nodes' keys
1 2           // 1 and 2 are linked
2 3           // 2 and 3 are linked
1 4           // 1 and 4 are linked
3 5           // 3 and 5 are linked
4             // # of seek() requests
2 3           // index 2 of tree, which would be key 5, 3 descendants from index 3 
4 1           // index 4 of tree, but only return highest from index 4 to 4 (it would 
              // return itself)
3 2           // index 3, next 2 descendants
3 2           // same

output:
5             // Returned index 5 because the 7 is the highest key from array[3 'til 5]
4             // Returned index 4 because the range is one, plus 4's children are null
5             // Returned index 5 because the 7 is the highest key from array[4 'til 5]
5             // Same as prior line

I was thinking about putting the new root into a new Red Black Tree, but can’t find a way to efficiently save successor or predecessor information for each node. Also thinking about putting into an array, but due to the nature of an unbalanced and unsorted tree, it doesn’t guarantee that my tree would be sorted, plus because it’s not a BST i can’t perform an inorder tree walk. Any suggestions as to how I can get the highest key from a specific range?

Answer 1

I dont understand very well what you mean by : “the number of descendants below the new node”. The way you say it, it implies there is a some sort of imposed tree walk, or at least an order in which you have to visit the nodes. In that case it would be best to explain more thoroughly what you mean.

In the rest of the answer I assume you mean distance from u.

From a pure algorithmic point of view, since you cannot assume anything about your tree, you have to visit all concerned vertices of the graph (i.e vertices at a distance <= v from u) to get your result. It means any partial tree traversal (such as depth-first or breadth-First) should be enough and necessary (since you have to visit all concerned nodes below u), since the order in which we visit the nodes doesn’t matter.

If you can, it’s simpler to use a recursive function seek'(u,v) which return a couple (index, key) defined as follows :

• if v > 1, you define seek'(u,v) as the couple which maximizes its second component among the couples (u, key(u)) and seek(w,v-1) for w son of u.
• else (v = 1) you define seek'(u,v) as (u, key(u))

You then have seek(u,v) = first(seek'(u,v)).

All of what I said presumes you have built a tree from the input, or that you can easily get the key of a node and its sons from its index.