Class 42: Binary Search Trees

Held Tuesday, April 18, 2000

Overview

Today we consider two simple implementations of dictionaries: association lists and binary search trees.

Notes

Contents

• A Dictionary Interface
• A Simple Dictionary Implementation
• Search Trees
  • Another Perspective: Binary Search Trees for Binary Search

Summary

• Dictionary ADT, revisited
• A simple implementation: Association lists
• An advanced implementation: Binary search trees

A Dictionary Interface

/**
 * Very simple dictionaries that map keys to values.
 *
 * @author Samuel A. Rebelsky
 * @version 1.1 of November 1999
 */
public interface Dictionary {
  /**
   * Add an entry to the dictionary.
   * Pre: The key and value are non-null.
   * Pre: The key can be compared to other values in the dictionary.
   * Post: Subsequent calls to get(key) will return value.
   *
   * @exception Exception
   *   If the key cannot be compared.
   */
  public void add(Object key, Object value)
    throws Exception;

  /**
   * Determine if a particular key is in the dictionary.
   * Pre: None.
   * Post: Returns true if the key is in the dictionary;
   *       Returns false otherwise.
   */
  public boolean contains(Object key);

  /**
   * Look up an entry in the dictionary.
   * Pre: The key is non-null.
   * Pre: The key can be compared to other values in the dictionary.
   * Post: Returns the value most recently "put" with the key.  
   *
   * @exception Exception
   *   If the key cannot be compared or there is no such entry.
   */
  public Object lookup(Object key)
    throws Exception;

  /**
   * Get a list of all the keys in the dictionary.
   * Pre: (None)
   * Post: Returns a list of all the keys.
   */
  public SimpleList getKeys();
} // interface Dictionary

A Simple Dictionary Implementation

• How can we implement dictionaries? There are a number of techniques. The simplest is like the association list that you saw in CS151.
• We could define a Pair object that joins a key and value.
• We could make an unordered array, vector, or list of those objects.
  • To insert an element, we put it at the beginning or end of the array, vector or list. This is generally O(1), depending on the structure we use.
  • To look up an element, we step through the pairs one by one, comparing the key we are searching for to the key in each pair. This is O(n), where n is the number of elements.
• We could make a sorted array of those objects (a sorted array being one that is always sorted).
  • To insert an element, we put it at the appropriate place, shifting as necessary. This is O(n) and is again limited by the size of the array.
  • To look up an element, we do binary search on the sorted array.
• It turns out that by using more sophisticated structures (e.g., nonlinear structures) or techniques (e.g., manipulating keys), we can do better.

Search Trees

• Another strategy for building dictionaries 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 smaller things and one to larger things.
• For example, we might build the following structure for the first six 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  Flynt  Jepsen
                   /    \
                 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 make the tree relatively balanced, this gives an O(log₂n) algorithm.
  • Unfortunately, keeping the tree balanced is difficult. That is a topic for CSC301.
• 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.

Another Perspective: Binary Search Trees for Binary Search

• We can also think about the structure by revisiting 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 data structure 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.

  public interface BinarySearchable 
  {
    /** 
     * Get the ``middle'' key in the collection. 
     * Pre: The collection is nonempty.
     * Post: Returns some designated element in the collection.
     */
    public Object middle();
  
    /** 
     * Get elements in the collection that are smaller than the
     * middle element.
     * Pre: The collection is nonempty.
     * Pre: The collection has not been modified since the last call
     *   to middle.
     * Post: Returns the smaller elements.
     */
    public BinarySearchable smaller();
  
    /** 
     * Get elements in the collection that are larger than the
     * middle element.
     * Pre: The collection is nonempty.
     * Pre: The collection has not been modified since the last call
     *   to middle.
     * Post: Returns the larger elements.
     */
    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 compare) {
      if (stuff.isEmpty())
        return false;
      else if (compare.equals(findMe, stuff.middle()))
        return true;
      else if (compare.lessThan(findMe, stuff.middle()))
        return binarySearch(stuff.smaller(), findMe, compare);
      else
        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(1) (as long as we're cautious about how we represent these structures).
• Binary search trees can provide another O(1) algorithm.