Keeping track of the number of nodes in the subtree in black and red trees

algorithmsbinary treetrees

I was wondering, if I have a black and red tree and I want to keep track of the number of nodes in the subtree, what is the most effective way to do so?

I mean how do I work with these values while insertion, deletion and rotation of nodes, so that I don't have to process the number under every node again?

Best Answer

Allow me to expound a bit on @Robert's comment.

What you're talking about is caching a result that can be computed. Caching should be viewed as an optimization, the premature application of which is a known evil, which is to say: only do it at such time as you have a measurable performance issue. Caches easily go out of date, and making them 100% accurate will necessarily complicate the code. (And if you depend on them during the insert, update, rotate operations, you now have to have them up to date within those operations, not just between operations.) Caching can also make multi threaded code more complicated.

You can store the counts as @Robert suggests. You will have to reason which nodes' cached subtree count values need to change whenever an insert, delete, or rotation happens, and write code to update the cached counts. However, you can reason from count to count instead of fully recounting. So, when you insert at a parent, the parent's count goes up by one, you don't have to recount the other children; similarly, the parent's parent count also goes up by one (if you're doing transitive counting) etc... Rotation should have a more local effect, and not bubble up thru all the parents.

Because with inserts and deletes, the count adjustment necessarily has to be made up thru the parents all the way to the root, this will have some negative performance impact, sometimes due to processor memory cache misses incurred when visiting parents that wouldn't have otherwise been visited. Having performance tests would be a good idea, so that the caching and non-caching versions can be compared.

Related Solutions

Usefulness of pre and post order traversal of binary trees

You need to do various things with trees, like translate between the data structure and some serial representation, like on a file or in a language.

So, for example, suppose you have a parse tree like this:

    *
   / \
  +   \
 / \   \
A   B   C

You could serialize it as * + A B C by walking it in prefix order, or as A B + C * by walking it in postfix order. If you work at all with language processors, such things need to be second-nature.

Data structures and algorithms for a directed rooted tree with inherited properties

A regular tree would suit just fine and Approach 1 would work here. I think you should also read up a bit about the search algorithms used for a B-tree and then see how you could modify it here.

To me, this question is basically about how to modify a generalized B-Tree to handle properties with a propagation element.

Like you say:

Store the tree as a regular tree.
Store properties with the nodes they are set on.

But:

Don't double link them - You can walk down the tree during the search (and also unfold if necessary revisiting the parent node when using typical recursive methods).
Don't create a hash-table - a hash-table is just another look-up data-structure, why use it when you can modify the tree!
DON'T DO THIS: Compute the properties inherited by nodes, by walking UP the tree ...
INSTEAD DO THIS: Store the properties as you walk through the tree locating the target node. You have to visit them anyway. During the node traversal search just pass through the property if 'propagate' is on. When at the child node; don't save it if the property also exists there and is set to 'turned off'. Keep traversing until you reach your target node, storing the properties as you go (perhaps in some simple little list).
Note that the property attributes requirements for 'propagate' and 'turned off' only impact the search algorithm by requiring logic to be placed in the traversal method.

PROBLEM 1: Computing properties on a set of nodes is slow. Dumb implementation results in O(PDN) although I have a feeling this can be improved.

SOLUTION: This is full of assumptions. What is a set? I only can assume a simple case like; set of nodes are all of the direct children of their parent node & depth of 1. Given this; Locate the parent node first with all the properties saved up until that parent node (as we just discussed in the previous point). Then for each child of that node you calculate out the properties - so for each child you have all the saved properties up to that parent node + the child's properties.
EXAMPLE: Traverse from the root node to a target node. For each node get the properties where they are 'propagated' and then traverse the next node passing through those properties. For the next node; for each property passed through check they are in the current node, if they are present and are 'turned on' then overwrite the property with the current nodes value. Then do the 'propagation' check and redo going through the nodes until the target node. Then you are left with the children - apply the same attribute logic and record the properties for each node.

PROBLEM 2: Finding out which nodes inherit a specific property in the whole tree is VERY slow and I don't see a good way to optimize it.

SOLUTION: Here, you want to search for this efficiently but the creation of your tree solution doesn't have to be so efficient. And it's not too complex because you just need to find if it is 'turned off' or not - and not involve the 'propagate' property. What you need to do here is use the tree as it is supposed to be used. If a property is not 'turned off' you want to say to the parent node that a child of theirs has a specific property and then update all the way back up to the root node. This way if a property doesn't exist at all you'll know straight away when visiting the root node that it doesn't exist.
EXAMPLE: Given a child node is set with a new property and 'turned on'; update the parent node with the same property and set to 'turned off' and use this to say the property exists in one of the nodes children. Then for each parent above that parent, set the same property and attribute. Now start to traverse from the root node the property will be set on the root node indicating that a descendant has that property. Do a traversal search and go through each child where the property is set - store each node where the property is 'turned on'.

Hopefully I can improve on this answer. Help me by indicating hard to understand parts of my answer.

Best Answer

Related Solutions

Usefulness of pre and post order traversal of binary trees

Data structures and algorithms for a directed rooted tree with inherited properties

Related Topic