CS62 - Spring 2010 - Lecture 13

An infinite number of mathematicians walk into a bar. The first one orders a beer. The second orders half a beer. The third, a quarter of a beer. The bartender says "You're all idiots", and pours two beers.

exercises 10.3 and 10.13

administrative
   - midterm on thursday
      - posted a rough outline of the topics covered
      - also posted some sample questions
   - lab this week will be review... come with questions!
   - assignment 5 is due on Friday at 6pm

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 in BinaryTree code

tree traversal
   - we can "traverse" a tree by visiting all of the nodes in the tree
   - why would we want to traverse all of the nodes?
      - we may want to ask a question about the data, e.g. search
      - we may want to print out the values in the tree in some order
      - we may want to process the values in the tree in some order
   - look at the four different traversal methods in BinaryTreeTraversal class in BinaryTree code
      - how do these traverse the data?
   - how do these relate to BFS and DFS?

some other tree methods
   - implement (can be found in BinaryTree code)
      - height
         - running time?
            - O(n)
      - depth
         - running time?
            - O(h)
      - size
         - running time?
            - O(n)
      - search
         - running time?
            - O(n)
   - isFull()
      - a tree is full if:
         - it's a leaf
         - both of it's children are full AND both of it's children are at the same height
      - look at isFullSlow() method
         - running time?
            - O(n h)