CS201 - Spring 2014 - Class 22

  • exercises

  • recursive DFS

  • search wrap-up
       - other applications:
          - game playing agents (e.g. chess)

  • tree terminology
       - nodes are the elements of a tree
       - edges connect the nodes
       - the root of the tree is the top of the tree
       - a subtree is any tree within the original tree (often including the original tree)
       - parent/child relationships
          - nodes have parents and children
          - the children of a node are the nodes directly under it
             - a node can have multiple children
             - for a binary tree, at most two children
          - the parent of a nodes is the the node directly above it in the tree
             - for a tree, a node only has one parent
             - all nodes except the root have a parent
       - ancestor/descendant relationship
          - a descendant of a node is any node under it in the tree (i.e. a child or a child or a child, etc.)
             - every node except the root is a descendant of the root
          - an ancestor of a node is any node above it in the tree (i.e. parent or a parent's parent, etc.)
             - similarly, the root is an ancestor of every node
       - siblings
          - two nodes are siblings if they have the same parent
       - leaf node
          - a leaf node is a node that does not have any children (i.e. at the bottom of the tree)
       - path
          - a path is a set of edges connecting nodes n and m
          - for a tree, we often say that a path must be the shortest set of edges from n to m
          - the length of the path is the number of edges along the path
       - height/depth of a node
          - the height of the tree is the maximum path from the root to any leaf
          - the depth of a node is the path length from the node to the root
             - the root is at depth 0
             - all children of the root at depth 1
             - etc.
       - degree of a tree
          - for now, we'll only talk about binary trees, but you can have n-ary trees
          - the degree of the tree is the maximum allowable number of children a node can have
       - tree types
          - simple tree (aka the loner)
             - a single node by itself
          - the twig
             - each node has one child
          - full tree
             - every node has 2 children except the leaves
          - complete tree
             - full binary tree except the leaves are filled in from left to right

       - tree properties
          - given a tree of height h
             - at most how many leaves does it have?
                - maximum occurs when the tree is full
                   - 2^h
                - in general, there are at most 2^d nodes at depth d
             - what is the maximum number of nodes?
                - the maximum number occurs when the tree is full
                   - bottom row has 2^h
                   - then 2^(h-1), 2^(h-2), ... , 1
                   - sum these up... 2^(h+1) - 1
             - what is the minimum number of nodes?
                - h+1, the twig
          - given a full tree, what is the height of the tree with respect to the number of nodes?
             n = 2^(h+1)-1
             log n = h+1 log 2
             h = O(log_2 n)

  • applications
       - expression trees
          - (2 + 3) * 4
          - ((4 + 2) * ((3 * 2) - 4)
          - 1 + 2 + 3 + 4 + 5
             - ambiguous!
       - geneology
       - huffman codes (compression)

  • look at BinaryTree code
       - similar idea to a linked list however, instead of just one "next" node we have a left and a right child
       - reinforces the idea that this is a recursive structure: a binary tree consists of a data item with left and right subtrees that are also binary trees
       - "data" stores the data at this node
       - "parent" references the parent
          - why do we keep track of our parent?
             - make some operations easier, e.g. depth
       - left and right keep track of the children
       - building a binary trees:
          - for now, just two constructors:
             - create a node with no children. When does this happen?
                - leaf node
             - create a node with children specified
                - internal node
                - where could we enforce the constraint that each node must contain two children?
                   - in the second constructor
          - how do we build a binary tree with this implementation?
             - from the bottom up!
          - ((4 + 2) * ((3 * 2) - 4)
          - look at buildSimpleTree method in BinaryTreeTraversal class
    •