Trees

In recursion.html#exprtrees we looked at some simple tree structures used for expressing "hierarchical" information: expressions:

2*(3+5)

         *
       /   \
      2     +
          /   \
         3     5

• data
• a left subtree
• a right subtree

The code might look like this (from bintree.cs)

    class treenode {
	private T data_;
	private treenode left_, right_;
	public treenode(T d, treenode l, treenode r) {data_ = d; left_ = l; right_ = r;}
	public T data() {return data_;}
	public treenode left()  {return left_;}
	public treenode right() {return right_;}
    }

A binary tree is ordered if there is an ordering relation on the data and, for each node, every data value appearing in the left subtree is less than the node's own data, and every data value appearing in the right subtree is greater than the node's own data.

Quite often, eg for expression trees, no ordering is involved.

The root node is at the top of the tree. Nodes with no subtrees (ie in which the subtree fields are null) are leaf nodes. Other nodes are interior nodes.

The depth of a node is how far it is, in node-to-node links, from the root. Level n of a tree consists of all nodes with depth n.

Examples:

• Abstract expression trees
• Parse trees
• Ancestry trees
• Decision trees (Bailey p 288)

None of these is ordered!

Tree Traversal

To traverse a tree is to visit each node, perhaps printing out the data values or perhaps taking some other action. Traversal methods are usually recursive, and usually the initial call is on the tree's root.

Three common forms of traversal are preorder, inorder, or postorder, depending on whether a node's data is visited before, between or after the left and right subtrees are visited. All of these are considered to be depth-first traversal. Here is a sample inorder traversal

Demo:

    traverse the expression tree for 4+x*(y+1)

        inorder

        postorder (cf Jan Łukasiewicz)

    traverse the following tree from simpletrees.zip:

Tree Building

How do we build trees? One way is from the bottom up; that is much easier of the class treenode is public. We could do this (assuming treenode is equivalent to treenode):

    treenode n1 = new treenode("a", null, null);
    treenode n2 = new treenode("3", null, null);
    treenode n3 = new treenode("*", n1, n2);
    treenode n4 = new treenode("1", null, null);
    treenode root = new treenode("+", n3, n4);

What does this build?

We can build ordered trees by inserting in order:

    public void insert(int val) {
	if (root_ == null) {
		root_ = new treenode(val, null, null);
		return;
	}
	rinsert(val, root_);
    }

    // recursive insert: does not get called with t==null
    private void rinsert(int val, treenode t) {
	if (val == t.data() ) return;	// should we do something else?
	if (val < t.data()) {
	    if (t.left() == null) {
		t.setleft(new treenode(val, null, null));
	    } else {
		rinsert(val, t.left());
	    }
	} else { // val > t.data()
	    if (t.right() == null) {
		t.setright(new treenode(val, null, null));
	    } else {
		rinsert(val, t.right());
	    }
	}
    }

If a treenode is null, we cannot modify it; we can only modify the parent. Bailey addresses this in some contexts by including a pointer to the parent node, but that won't help us here.

Note that the tree we get by inserting values depends on the order of insertion. 

In-class demos: 

• try inserting the values in order
• what orders lead to the same tree?
• convert to preorder traversal

n-ary trees and ordered n-ary trees

    depth(LL) +1 = max(depth(LRL), depth(LRR))

The general rule is that we need to do two rotations (about L and then X in the first diagram) if the balance factors at L and at X have different sign (eg +2 at X and -1 at L, or -2 at X and +1 at L).

Generally these are known as B-trees. Bayer named them that in his paper, though he did not spell out what the B stood for. B-trees are not binary trees; in fact, you might look at them as evidence that being binary makes life much harder.

Bayer's co-author was McCreight, who in 2013 said the following:

Bayer and I were in a lunchtime where we get to think [of] a name. And ... B is, you know ... We were working for Boeing at the time, we couldn't use the name without talking to lawyers. So, there is a B. [The B-tree] has to do with balance, another B. Bayer was the senior author, who [was] several years older than I am and had many more publications than I did. So there is another B. And so, at the lunch table we never did resolve whether there was one of those that made more sense than the rest. What really lives to say is: the more you think about what the B in B-trees means, the better you understand B-trees.

So maybe the B stands for Boeing.

B-trees have what I will call an order, d. Each interior node (other than the root) has k nodes, d<=k<=2d, and k+1 children. The k values, a₀...a_k-1, divide the leaf data into k+1 categories: x<a₀, a_i<x<a_i+1 for i=0..k-1, and a_k+1<x. These categories form the k+1 children; thus, a B-tree is still an ordered tree even if it is not binary. All leaf nodes are the same depth in the tree.

The nomenclature for B-tree order is not entirely consistent; some people use 2d, or even 2d+1, as the order of what is called an order-d tree above. For greater consistency, we can identify B-trees by their maximum degree, which is the maximum number of children a node can have. A B-tree of order d, as above, has degree 2d+1.

2-4 Trees

Before proceeding to red-black trees we consider 2-4 trees, which are a form of B-trees. The tree is ordered, and each node is allowed to have between two and four children. The number of data values at a node is one less than the number of children. An additional requirement is that all leaf nodes must be at the same depth.

Insertion is similar to a B-tree. We start by adding the new value u to the appropriate leaf node, finding that leaf node using the tree ordering. Leaf nodes can contain between 1 and 3 data values. If adding u would give the leaf node four data values, we push the median value of the node up to the parent, and split the node into two (those less than the median and those greater than the median, which go on the right and left respectively of the pushed-up value).

This may cause the parent node to be too big, in which case we repeat the process. If we must add a new node at every level, then we end up splitting the existing root node and creating a new root above it.

Red-Black Trees

Let the black-height of the tree be the number of black nodes in any path from the root to a leaf, constant as per property 5. Property 4 ensures that, along any path, the path length is no more than twice the black-height.

2-4 Tree analogy

From a red-black tree we can create a 2-4 tree consolidating each black node together with any black grandchildren of a red child. If a node N is black and has one red child, this will give N three black children. If N has two red children, it will now have four black children.

We can convert a 2-4 tree back to a red-black tree in a unique way if we require that the red-black tree be left-leaning; that is, that if a black node has a red and a black child, then the red child is the left one. Given a node N in the 2-4 tree, we do the following:

• if N has two children, we leave it alone.
• if N has three children n1, n2 and n3, we create a new red child node to N's left and move n1 and n2 so they are children of the red node. N's right child is n3.
• if N has four children, we create two red child nodes. The first red node gets the first two of N's children, and the second red node gets the second two.

We know how to insert into a 2-4 tree so as to maintain the 2-4 property. Because the 2-4 property is functionally equivalent to the red-black property for the corresponding red-black tree, we can now maintain red-black trees.

We create a B-tree-like structure by consolidating each black node together with any red offspring. Let us refer to the consolidation of a black node with its red children as a B-node; a B-node will now have between 1 and 3 data values, and between 2 and 4 children. It then follows from rule 5 that the tree made from the B-nodes has all paths of the same length. It follows from rule 4 that the offspring of any red offspring are black, and so if we identify a B-node in the original tree, the immediate children of this node must all be black.

The catch is that the tree we create this way isn't quite a proper B-tree. A B-tree of order 1 has 1 or 2 data values per node, and 2 or 3 subtrees; a B-tree of order 2 has 2, 3 or 4 data values per non-root node with 3, 4 or 5 children. The B-like tree here has 1, 2 or 3 data values per node, and 2, 3 or 4 subtrees.

Given a B-like tree with 1-3 data values per node, maintaining the B-tree property of all paths having equal length, we can convert it to a red-black tree as follows:

1. If a B-node has 1 value, it becomes a single black node
2. If a B-node has two values, it becomes two nodes. The upper one will be black and the lower one red; it does not matter which is which.
3. If a B-node has three values, the middle value becomes a black node and the two other values become red nodes representing the roots of the left and right subtrees.

Inserting into a B-like tree with 1-3 data values per node is similar to insertion into a regular B-tree, except that when a node is "full" with three values, and we split it and push up a middle value, the split will be into pieces of sizes 1 and 2. It does not matter which piece is which; if a node contains values (10,15,20) and we add 18, we can push up either the 15, with split nodes (10) and (18,20), or the 18, with split nodes (10,15) and (20).

Realistically, there is no reason to prefer the red-black formulation to a proper B-tree formulation. There is no especial benefit to having trees be binary.

Here is the algorithm for "directly" inserting into a red-black tree, without converting to a 2-4 tree or a B-like tree

Let us refer to the sibling of the parent of a node as the uncle; the uncle of a node, if it exists, is always unique because the tree is binary. The first step is to add the new node to the tree in the usual binary-tree-insertion manner; we must then rotate and recolor in order to restore red-blackness. The important red-black requirements are 4 and especially 5.