Tree height
===========

Suppose a binary tree contains three nodes. What is its height?

a.  either 0 or 1
b.  1
c.  *either 1 or 2*
d.  2
e.  not enough information to tell

Tree size
=========

What are the possible sizes of a binary tree of height 3?

a.  15
b.  between 1 and 15 (inclusive)
c.  *between 4 and 15*
d.  between 8 and 15
e.  not enough information to tell

Duplicate values
================

Suppose we allow left children to be less than or equal to, and right
children to be greater than or equal to. A binary search tree of
`Integer`s has two nodes storing value 7, called `u` and `v`. Neither
`u` nor `v` is an ancestor of the other. Which of these is possible?

a.  No node other than `u` or `v` stores 7
b.  *There are exactly three nodes with value 7* (depending upon `add`)
c.  *Nodes `u` and `v` are both descendants of a node with value 8*
d.  Either `u` or `v` is the root of the tree

`size()`
========

Suppose that `recSize(tree)` has one of the following bodies. Which
version will correctly return the size of any nonempty binary tree?

a.  `return 1 + recSize(tree.getLeft()) +` `recSize(tree.getRight());`
b.  `if (tree == null) return 0;`
    `if (tree.getLeft() != null) return 1 +`
    `recSize(tree.getLeft()); if (tree.getRight()`
    `!= null) return 1 + recSize(tree.getRight());`
c.  *`int sum = 1; if (tree.getLeft() != null)`
    `sum += recSize(tree.getLeft());`
    `if (tree.getRight() != null) sum +=`
    `recSize(tree.getRight()); return sum;`*
d.  none of these

Iterative size
==============

The iterative `size()` method uses a stack to hold the
"work-in-progress." What happens if we use a queue instead?

a.  the method performs exactly the same actions
b.  *the method performs a different sequence of actions, but returns 
    the same result*
c.  the method returns a different result
d.  the method can now throw a `NullPointerException`

Recursive `get`
===============

Consider the recursive `get` method that is analogous to the recursive
`contains` method. Suppose there are multiple entries in the tree with
the same value. Which of these statements is true?

a.  `get` might return any of the entries
b.  `get` will not return the value of a leaf node
c.  `get` must return the leftmost of the entries
d.  *all of the above are *false** (depending upon the order of `if`s in the method)