Serializing Trees using FIRSTKEY/NEXTKEY methods?

rrwo has asked for the wisdom of the Perl Monks concerning the following question:

I have a binary tree as the backend for a tied hash. I'd like to be able to have it serialized with things like Data::Dumper etc., which requires the FIRSTKEY and NEXTKEY methods.

My question is: what's the best way, given these constraints?

I expect the only way is to use a stack. STaring from the root node:

return a node
push the left leaf on a stack and
go right;
when no leaves are left, pop the stack and repeat.

Is there a more efficient way?

Comment on Serializing Trees using FIRSTKEY/NEXTKEY methods?

Replies are listed 'Best First'.
Re: Serializing Trees using FIRSTKEY/NEXTKEY methods? by chipmunk (Parson) on Jul 11, 2001 at 08:00 UTC
There are various methods of walking a tree: depth-first (children, then parent), breadth-first (parent, then children), and in-order (left child, parent, right child), top-down, and bottom-up are the obvious ones. The algorithm you describe is top-down; first the root node is processed, then its children, then its children's children... Offhand, I think that the approaches are all pretty much the same in terms of efficiency for dumping the tree. The only difference is the order in which the data comes out. So the main consideration is rebuilding the tree afterwards, when your tied hash's STORE method is called over and over again. If you know what order you will be getting the nodes in, you could possibly optimize recreating the tree. For this, I think either breadth-first or top-down would be best; one of the orders that processes the parent before its children.	[reply]
Re: Serializing Trees using FIRSTKEY/NEXTKEY methods? by tadman (Prior) on Jul 11, 2001 at 07:55 UTC
You would need the two methods to be defined something like: `sub FIRSTNODE { my ($root_node) = @_; my $node = $root_node; while ($node->{left}) { $node = $node->{left}; } return $node; } sub NEXTNODE { my ($node) = @_; if ($node->{right}) { $node = FIRSTNODE($node->{right}); } elsif ($node->{parent}) { if ($node->{parent}->{left} == $node) { $node = $node->{parent}; } else { while ($node->{parent}->{right} == $node) { $node = $node->{parent}; } return unless $node; $node = $node->{parent}; } } else { $node = undef; } return $node; }` [download] The NEXTNODE method there traverses the tree, looking for the next logical node. This assumes that your B-Tree implementation uses a hash-style tree with references between nodes. To switch it to using text keys instead, you could write wrapper methods, as proposed below, or modify the code slightly to set $key instead of $node. The FIRSTKEY/NEXTKEY methods would merely return the key instead of the node reference, something like: `sub FIRSTKEY { my $node = FIRSTNODE($root_node); return $node && $node->{key}; } sub NEXTKEY { my ($key) = @_; my $node = NEXTNODE (FindNode ($key)); return $node && $node->{key}; }` [download]	[reply] [d/l] [select]