Class 53: Implementing Dictionaries with Binary Search Trees

Held: Wednesday, 5 May 2004

Summary: Today we consider a tree-based implementation of dictionaries, the binary search tree.

Related Pages:

• EBoard.
• BinarySearchable.java.

Notes:

• Are there questions on Homework 8?
• What time can everyone leave on Monday?

Overview:

• An ADT for binary search.
• Implementing that ADT with arrays.
• Binary search trees.
• BSTs and dictionaries.

A Data Structure for Binary Search

• We've used binary search on arrays, but are there other structures we can use it on? We might answer this by considering the operations binary search requires (and, therefore, the abstract data type specification).
• What operations do we need to do binary search?
  • Grab the middle element.
  • Grab the smaller elements: everything less than the middle element.
  • Grab the larger elements: everything greater than the middle element.
• We might build a data structure (or at least an interface) that directly supports those three operations.

  
  /**
   * Collections that support the key operations for binary search.
   *
   * @author Samuel A. Rebelsky
   * @version 1.1 of May 2004.
   */
  public interface BinarySearchable 
    extends Collection
  {
    /** 
     * Get the ``middle'' value in the collection. 
     * Preconditions: 
     *   (1) The collection is nonempty.
     * Postconditions: 
     *   (2) Returns some designated element in the collection.  That element
     *       should be less than approximately half the elements and greater 
     *       than approximately half the elements.
     */
    public Object middle();
  
    /** 
     * Get elements in the collection that are smaller than the
     * middle element.
     * Preconditions: 
     *   (1) The collection is nonempty.
     * Postconditions: 
     *   (1) Each element in the returned collection is smaller than or equal
     *       to the value returned by middle.
     *   (2) Any element in the original collection that is smaller than or
     *       equal to the value returned by middle is in the returned collection.
     */
    public BinarySearchable smaller();
  
    /** 
     * Get elements in the collection that are larger than the
     * middle element.
     * Preconditions: 
     *   (1) The collection is nonempty.
     * Postconditions: 
     *   (1) Each element in the returned collection is greater than or equal
     *       to the value returned by middle.
     *   (2) Any element in the original collection that is greater than or
     *       equal to the value returned by middle is in the returned collection.
     */
    public BinarySearchable larger();
  
    /**
     * Determine if the collection is empty.
     */
    public boolean isEmpty();
  } // BinarySearchable
  
  
  

• Rephrasing binary search in terms of these operations,

    public boolean binarySearch(BinarySearchable stuff, 
                                Object findMe,
                                Comparator order) 
    {
      if (stuff.isEmpty())
        return false;
      int compareVal = order.compare(findMe, stuff.middle());
      if (compareVal == 0)
        return true;
      else if (compareVal < 0)
        return binarySearch(stuff.smaller(), findMe, compare);
      else ; if (compareVal > 0)
        return binarySearch(stuff.larger(), findMe, compare);
    } // binarySearch(BinarySearchable, Object, Comparator)
  

• We already know how to implement such structures using sorted arrays. An advantage of sorted arrays is that all the operations are O(log₂n) (as long as we're cautious about how we represent these structures).

Search Trees

• Another strategy for building searchable structures is to use search trees. Search trees use the basic idea of binary search, but encapsulate it in a particular way.
  • As in the case of heaps, search trees apply the divide-and-conquer approach to the design of data structures.
• Can we also represent such structures as linked objects, using nodes?
• Yes, we'll give each node two links: one to a tree of smaller things and one to a tree of larger things.
• For example, we might build the following structure for the first seven letters of the alphabet.

        D
      /   \
     B     F
    / \   / \
   A   C E   G
  

• Similarly, here's a structure for the names of some faculty members.

                Rebelsky
               /        \
           Ferguson    Walker
          /     \       /    \
  Chamberland  Herman Stone Wolf
     /         /   \
  Adelberg   Gum   Jepsen
     \             /    \
    Bishop       Hill  MooreE
                          \
                         MooreT
  

• Such structures are called binary search trees
  • Binary: there are no more than two child links per node.
  • Search: you use them for looking for things.
  • Trees: They look somewhat like upside-down trees .
• How do we use search trees? The same way we use binary search.
  • To find an element in a search tree, you compare the object you're looking for to the current node. If the object you're looking for is smaller, you follow the left branch. If the object you're looking for is bigger, choose the right branch.
• We can use a similar process to insert an element.
  • You look at the current node.
  • If the node is empty, you build a new node.
  • If the node contains the appropriate key, you replace it.
  • If the value to be inserted is larger, you recurse on the right subtree.
  • If the value to be inserted is smaller, you recurse on the left subtree.
• If we can keep the tree relatively balanced, this gives an O(log₂n) algorithm.
• In order to implement Dictionary with binary search trees, we'll build a wrapper class. This class will permit us to
  • Represent empty collections.
  • Keep track of the Comparator used to determine large and small.

Using Binary Search Trees for Dictionaries

• As should be obvious, we can use binary search trees to implement dictionaries.
• What are the advantages and disadvantages for doing so (as compared to, say, hash tables?