Outline of Class 40: Implementing Trees

Miscellaneous

• I'm hoping to get everything graded by next Monday, but we'll see how it goes. My book chapter still takes precedence.
• Any last-minute questions on assignment 8?
• I should have the next assignment ready for you tomorrow morning. It will be due Tuesday before Thanksgiving.

Implementing Trees

• Our implemention of expression trees provides a sound basis for our implementation of more general trees.
• As in our implemention of lists, we will begin by building the nodes that form trees, and then add a wrapper class that permits improved usage.

Implementing Trees with Nodes

• As with lists, it is possible to implement trees directly with a TreeNode class and without a wrapper class.
• While TreeNodes will have many similarities to ListNodes, there will be some differences:
  • We need to support more than one next element (child). We could do that by creating a separate variable for each child or by building an array or vector of children.
  • We need to keep track of how many children we have. We can use the size of the array or vector, but it may be useful to have separate access to that information.
  • We may need to consider the arity of our objects in the constructor.
• We also have to make some of the same decisions we made for list nodes.
  • Do we want unidirectional or bidirectional links? Bidirectional links support a parent() method, but unidirectional links (parent to child) permit reuse of the same subtree in multiple trees and may be easier to support.
  • Should each node keep track of its depth? This makes computation easier, but modification harder.
• We may also put more in this implementation than we put in the list implementation, since we now know about useful structures like iterators (e.g., we'll support an interator for our tree).
• We also have a number of questions to ask ourselves in the design, such as whether the arity of a node can change. If so, how do you determine the current arity of a node?
• If we allow variable-arity nodes, it becomes important to consider the appropriate preconditions for setChild(). For example, can you set the fifth child of a node with no children?

A Simple Implementation

• For the simplest implementation of tree nodes, we'll only provide links to children, and not to parents. This helps us avoid all the indirect implications of setting a child or parent link.
• We'll need fields for the contents of each node and for the children (which we'll represent as an array). Since we can infer other information from those two fields, will use only those two.

  /** The value stored in the current node. */
  protected Object value;
  /** The children of the current node. */
  protected Node[] children;
  

• We'll use fixed-arity nodes, but allow users to specify the arity of nodes when nodes are created.
• This means that we'll need to require an arity in the constructors (unless it can be inferred).
• All of our constructors will require a non-null root value, giving us a few standard preconditions:

  pre: The new root value is non-null.
  pre: There is sufficient memory to create the new node.
  

• One type of constructor takes the root value and "set" of chlidren (which can be represented in many different way).

  /**
     Construct a new node, given the root value and set of children.
     post: A new node is constructed.
   */
  public TreeNode(Object value, TreeNode[] children)
    throws MemoryException
  {
    this.value = value;
    // Create a new child array so that modifications to the original
    // don't affect us.
    this.children = new TreeNode[children.length];
    if (this.children == null)
      throw new MemoryException("Couldn't allocate children");
    for (int i = 0; i < children.length; ++i) {
      this.children[i] = children[i];
    } // for
  } // TreeNode(Object,Object[])
   
  public TreeNode(Object value, Iterator children)
    throws MemoryException
  {
    this.value = value;
    // Determine the number of elements in the interator (hmmm ...
    // should iterators have a size() method?)
    int elements = 0;
    for(children.reset();
        children.hasMoreElements();
        children.nextElement()) {
      ++elements;
    } // for
    // Allocate the new children array
    this.children = new TreeNode[elements];
    if (this.children == null)
      throw new MemoryException("Couldn't allocate children);
    // Copy
    for(int i=0,children.reset();
        (i < elements) && children.hasMoreElements(),
        ++i) {
      this.children[i] = children.nextElement();
    } // for
  } // TreeNode(Object,Iterator)
  

• We might also want to permit the creation of nodes without the specification of the children.

  /**
     Create a new node with a particular value and arity.
     pre: The arity is non-negative.
     post: A new node is created.
   */
  public TreeNode(Object value, int arity)
    throws MemoryException
  {
     this.value = value;
     this.children = new TreeNode[arity];
     if (this.children == null)
       throw new MemoryException("Can't allocate children");
  } // TreeNode(Object,int)
  

• Since binary nodes are so common, we might also want to provide a constructor specifically aimed to supporting them.

  /**
     Create a new binary node with value and children.
     post: A new node is created.
   */
  public TreeNode(Object value, TreeNode left, TreeNode right)
    throws MemoryException
  {
    this.value = value;
    this.children = new TreeNode[2];
    if (this.children == null)
      throw new MemoryException("Can't allocate children");
    this.children[0] = left;
    this.children[1] = right;
  } // TreeNode
  

• The basic access methods are relatively straightforward

  /**
     Get the value associated with the current node.
     post: The value is returned.
   */
  public Object getValue() {
    return this.value;
  } //getValue
   
  /**
     Get one of the children of the current node.
     pre: The child number is non-negative.
     pre: The child number is less than the arity of the current node.
     post: The child or null is returned.
   */
  public Object getChild(int childnum) {
    // Sanity check removed
    return children[childnum];
  } // getChild
  

• The basic modification methods are also straightforward.

  /**
     Set the value associated with the current node.
     pre: The value is non-null.
     post: The current node now contains the new value.
   */
  public void setValue(Object value) {
    this.value = value;
  } // setValue
   
  /**
     Set one of the children of the current node.
     pre: The child number is non-negative.
     pre: The child number is less than the arity of the current node.
     post: The child is set.
   */
  public void setChild(int childnum, TreeNode child) {
    // Sanity check removed
    children[childnum] = child;
  } // setChild
  

• Note that deleteChild(n) is not strictly necessary, as we can simply call setChild(n,null). However, it may be useful to provide a separate deleteChild(n) so that we can choose other ways to represent empty nodes.

Adding an Iterator

• Can we build an iterator based on these simple tree nodes? Certainly, and there are a number of ways to do so.
  • We could traverse the tree and shove all of the nodes into a linear structure and then return the iterator for that structure.
  • We could build the iterator for the current node in terms of the iterators of its children. To get the next element, you determine which child iterator is "current" and get the next element from that iterator.
  • We could keep track of where we've been and haven't been in the tree.
• Which is best? The first is certainly the easiest, although it requires the most computation to create the iterator.
• Here's a simple implementation (which should be included in the TreeNode class)

  /**
     Build an interator for the tree rooted at the current node.
     post: The iterator contains all the nodes currently in the tree.
   */
  public Iterator elements() {
    // We wouldn't really use a Linear here, but it makes a good
    // generic exmaple.
    Linear temp = new Linear();
    addElements(temp);
    return temp.elements();
  } // elements()
   
  /**
     Add all the elements at or below the current node to a linear
     structure.  Note that there are many ways to do this, and the
     way in which you do it (as well as the linear structure used)
     affects the order in which elements appear.
     pre: The linear structure is initialized.
     pre: The lienar structure has room for the elements.
     pre: The node is used in a tree (in particular, there is no path
          from this node back to this node based only on child edges).
     post: All the elements are added to the linear structure, even
           if they are already there.
   */
  private void addElements(Linear stuff) {
    stuff.add(value);
    for (int i = 0; i < children.length; ++i) {
      if (children[i] != null)
        children[i].addElements(stuff);
    } // for
  } // addElements()