1. Paolo Ferragina Dipartimento di Informatica, Università di Pisa
Representing Trees
Paolo Ferragina
Dipartimento di Informatica, Università di Pisa
Paolo Ferragina, Università di Pisa

2. Standard representation
Binary tree: each node has two
pointers to its left and right children
An n-node tree takes
2n pointers or 2n lg n bits.
Supports finding left child or right child of a node (in constant time).
For each extra operation (eg. parent, subtree size) we have to pay additional n lg n bits each. x x x x x x x x x

3. Can we improve the space bound?
There are less than 22n distinct binary trees on n nodes.
2n bits are enough to distinguish between any two different binary trees.
Can we represent an n node binary tree using 2n bits?

4. Binary tree representation
A binary tree on n nodes can be represented using 2n+o(n) bits to support:
parent
left child
right child
in constant time.

5. Heap-like notation for a binary tree1
Add external nodes 1 1
Label internal nodes with a 1
and external nodes with a 0 1 1 1 1 1
Write the labels in level order
One can reconstruct the tree from this sequence
An n node binary tree can be represented in 2n+1 bits.
What about the operations?

6. Heap-like notation for a binary tree1
x  x: # 1’s up to x (Rank1(x))
x  x: position of x-th 1 (Select1(x)) 1 2 3 2 3 4 5 6 7
Let x be an internal node:
left child(x) = On green(2x)
right child(x) = On green(2x+1)
If bit is 0 then pointer is NULL 4 5 6 12 8 9 10 11 13 7 8
Let x be an internal node or a leaf:
- parent(x) = On red (⌊x/2⌋) 14 15 16 17

7. Arbitrary fan-out
A rooted ordered tree (on n nodes, arbitrary fan-out):
Navigational operations:
- parent(x) = a
- first child(x) = b
- next sibling(x) = c
Other useful operations:
- degree(x) = 2
- subtree size(x) = 4 a x c b

8. Level-order degree sequence (LOUDS)3
Write the degree sequence in level order 2 3
But, this still requires n lg n bits 1 2
Solution: write them in unary
Takes 2n-1 bits
(every node is represented twice, as 0 and as 1,
except the root represented only as 0)
A tree is uniquely determined by its degree sequence

9. Supporting operations
Add a dummy root so that each node has a corresponding 1 1
Node k corresponds to the k-th 1 in the sequence
Children of k correspond to the 1s following the k-th 0 3 4 2
First_child(k): y=Select_0(k)+1
if B[y] = 0 then leaf
else return y-k [i.e. #1 up to y]
Next sibling(k) = k+1 if B[Select_1(k)+1] ≠ 0
Parent(k) = # 0’s up to the k-th 1 7 9 5 6 8
degree(k) = Select_0(k+1) – First_child(k)
In 2n+o(n) bits and constant time per ops.
No support for subtree size. 10 11 12