Tree Data Structures

Lets take a look at one of my favorite implementations of the tree data structure and identify some terminology along the way:

Figure 1: A tree data structure modeling one of Great Houses of Westeros

Nodes

Trees are organized into nodes that hold data along various branches. Nodes are related through parent, child, and sibling relationships.

Roots

Every tree has a root node at the highest level (ie: Rickard Stark). Every node is also the root of a subtree. We can see that Ned Stark is the root node of the subtree containing him, Robb, Sansa, Arya, Bran, and Rickon.

Depth

Depth refers to the level at which a node sits relative to the root. When referring to the entire tree, a root node, like Rickard Stark has a depth of 0, while Jon Snow and Arya Stark have a depth of 2. However, depth is also relative to a subtree. If we were only considering Ned Stark's subtree, Arya would have a depth of 1.

Height

The height of any node is measured through the deepest child node it has. So the height of Benjen Stark is 0, while the height of Rickard Stark is 2.

Designing a General Tree Data Structure

Strategy

To represent a tree, it would be useful to abstract away the "spider web" feel of the actual tree into something more manageable. Imagine that each node has 2 reference pointers firstChild and nextSibling. Then, we can represent the tree in a chained hierarchy structure focussed on node depth. It would look something like this:

Figure 2: Efficiently representing House Stark with our TreeNode class

Implementing a `TreeNode`

In practice, we would actually need more than just those 2 pointers to work with the tree efficiently. Here is an outline of our TreeNode class:

Instance Variables

data <String> - Stark family member's name (ie "Ned Stark")
firstChild <TreeNode> - A pointer to a child of this, if any
nextSibling <TreeNode> - A pointer to a sibling of this, if any
previousNode <TreeNode> - A pointer to previous Node along the chain (see Figure 2)
myRoot <TreeNode> - A pointer to the root node associated with this

`TreeNode` class structure

public class TreeNode {
    protected TreeNode firstChild, nextSibling, previousNode;
    protected String data;
    protected TreeNode myRoot;
    
    public TreeNode() { 
      // Constructor Logic...
    }
    
    public E getData() { 
      return data; // Accessor
    }
}

Data that Could be Stored in a `Tree`

`<TreeNode> this`	`this.firstChild`	`this.nextSibling`	`this.previousNode`
`rickardStark`	`nedStark`	`null`	`null`
`nedStark`	`robbStark`	`brandonStark`	`rickardStark`
`brandonStark`	`null`	`benjenStark`	`nedStark`
`benjenStark`	`null`	`lyannaStark`	`brandonStark`
`lyannaStark`	`jonSnow`	`null`	`benjenStark`
`robbStark`	`null`	`sansaStark`	`nedStark`
`sansaStark`	`null`	`aryaStark`	`robbStark`
`aryaStark`	`null`	`branStark`	`sansaStark`
`branStark`	`null`	`rickonStark`	`aryaStark`
`rickonStark`	`null`	`null`	`branStark`
`jonSnow`	`null`	`null`	`lyannaStark`

Implementing a `Tree` class

Let's take a mini tour of a barebones Tree class linking together TreeNodes. We'll focus on the find() method for now and assume an object of this class called starkFamilyTree is already setup.

public class Tree {
    private int mSize;
    TreeNode mRoot;

    public Tree() { 
        // Constrcutor Logic...
    }
    
    // Client side find() function
    public TreeNode find(String data) { 
        return find(mRoot, data, 0); // Runs private recursive version of find()
    }
    
    // Recursive logic - overloaded find()
    private TreeNode find(TreeNode root, String data, int level) {
        TreeNode stackResponse;
        
        if (mSize == 0 || root == null) // Base case 1 (nothing to search)
            return null;
        
        if (root.data.equals(data)) // Base case 2 (found!)
            return root;

        if (level > 0) {
            stackResponse = find(root.nextSibling, data, level); // Recursive Call
            if (stackResponse != null)
                return stackResponse; // Base case 3 (forward result it along the recusrive chain!)
        }

        return find(root.firstChild, data, ++level); // Recursive Call
    }
}

Recursion

To traverse a tree, and check out different nodes on the way we usually use recursion. I really like Mattias Petter Johansson's definition of recursion (check out his awesome YouTube channel Fun Fun Function)

Recursion is when a function calls itself until it doesn't. That is seriously all recursion is. It's really simple.

With that in mind, we see that private TreeNode find(TreeNode root, String data, int level) calls itself mutltiple times. Each call, generates a Stack Frame (a snapshot of the call's local variables), and recursion aims to pile and unpile these Stack Frames. Luckily base cases help us break out of this cycle and eventually end up with one answer.

Let's assume we have a Tree object named starkFamilyTree already setup, so we can try to find() aryaStark. Since a girl has many faces lol, we have to be very careful with our recursive process - it can get very complicated. Follow along if you like, this is the whole procedure...

Global - calls Function

This frame runs the following global code statement:

TreeNode result = starkFamilyTree.find("Arya Stark"); // Call into Function

Stack Frame	Global
global variable	value
result	starkFamilyTree.find("Arya Stark")	awaiting return from Function

Function - calls Node 0

This frame runs the following code statement from

public TreeNode find(String data)

        return find(mRoot, data, 0); // Recursive Call to Node 0 (rickardStark)

Stack Frame	Function
local variable	value
mRoot	rickardStark
data	"Arya Stark"
return value	find(rickardStark, "Arya Stark", 0)	awaiting return from Node 0 & will eventually return to Global