Trees

• binary and other kinds of trees
• tree representation
• class for binary trees

Trees for Computers

• Like genealogy trees -- root is at the top, leaves at the bottom
• like a list, a tree is made of nodes:
  • in some trees, every node holds data
  • other times, only leaf nodes hold data
• each node may have one or more children: there is a reference from the parent to the child, but (usually) no reference from the child to the parent.
• a tree in which each node has at most 2 children is a binary tree: the possible children are the left child and the right child
• a tree in which each node has at most one child would be very much like a list

Tree Words

• root, leaf, child
• the node that points to me is my parent
• my parent, and its parent, and its parent, and so on, are all ancestors of mine
• any node (besides myself) that my parent points to is my sibling
• my children, and all their children, and so on, are all descendants of mine
• in a binary tree, the sub-tree rooted at the left child of a node is the left subtree of that node, and similarly for the right subtree
• the number of links between a node and the root (going "backwards") is the depth of that node. The root has depth zero.
• the maximum depth of any leaf of a tree is the depth of that tree

Types of Binary Trees

• a binary tree where every leaf has the same depth and all non-leaf nodes have 2 children is a full binary tree. A full binary tree of depth n always has 2^{n + 1} - 1 nodes
• a binary tree of depth n which:
  • is a full binary tree if we disregard the nodes at depth n, and
  • in which all the nodes at depth n are as far to the left as possible,
  is a complete binary tree. A complete binary tree of depth n has between 2ⁿ and 2^{n + 1} - 1 nodes.

Binary Taxonomy Trees

• 20-questions
• example: a tree to store four animals, a kangaroo, a mouse, a trout, and a pigeon
• "mammal?" distinguishes the first two from the last two
• "bigger than a cat?" distinguishes the first two
• "underwater?" distinguishes the last two

Array storage of complete binary trees

• we can very naturally associate an integer with every node of a complete binary tree:
  • the root is at index 0
  • the two children of the node at index n are at 2n+1 and 2n+2
• these integers are:
  • consecutive (no gaps)
  • easily computed given the position in the tree.
  • for example, the integers for parents, siblings, and children are all easily computed
• we can use these integers as indices to an array that stores the elements of the nodes

Breadth-first and Depth-first

• a complete binary tree stored in an array tree is stored "breadth-first": we store all the nodes at the same depth before storing any node at lower depth
• an alternative way (which does not work out as neatly for array storage) would be to store the array in "depth-first" order: we (recursively) store the entire left subtree before any node in the right subtree.

In-class Exercise

• 5 minutes
• work alone or in groups of up to 3
• store this complete binary tree into an array of 11 characters

Node storage of binary trees

• extend the idea of a list node:

  class BTNode {
    private Object data;
    private BTNode left;
    private BTNode right;
    ...
  }
  

• instead of the head of a list, we have the root of a tree:

    BTNode root;
  

• constructor:

  public BTNode (Object initialData,
                 BTNode initialLeft,
                 BTNode initialRight)
  

Node operations

• get and set data, left, and right
• public boolean isLeaf()
• public boolean getLeftmostData() (same for right)
• public static BTNode treeCopy(BTNode root)

• public boolean removeLeftmost() {
    if (left == null)
      return right;
    left = left.removeLeftmost ();
    return this;
  }