Class 41: Search Trees

Held Thursday, November 11, 1999

Overview

Today we continue our discussion of dictionaries with a few possible implementation strategies.

Notes

• Here's the schedule we've decided on for the project
  • Monday, November 15, 1999: Working components due
  • Wednesday, November 17, 1999: Discussion and integration
  • Friday, November 19, 1999: More integration
  • Monday, November 22, 1999: Presentation preparation (in class); Presentation (lunchtime)
  • Monday, December 6, 1999: Final versions due.
• For those of you who took CS151 with Clif Flynt, Clif says hi.
  • A paper we wrote on the large project experience in CSC152 was just accepted to the SIGCSE conference on computer science education.

Contents

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

Summary

• Dictionaries, codified
• Implementing dictionaries with association lists
• Implemented dictionaries with search trees
  • Balancing trees?
  • Binary search trees and binary search

A Dictionary Interface

/**
 * Very simple dictionaries that map keys to values.
 *
 * @author Samuel A. Rebelsky
 * @version 1.0 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 put(Object key, Object value)
    throws Exception;

  /**
   * 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 get(Object key)
    throws Exception;

} // 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.

  
  /**
   * Nodes in a binary search tree.  It is expected that you will
   * access the fields directly, as this is only used as a helper
   * for other classes.
   *
   * @author Samuel A. Rebelsky
   * @version 1.1 of November 1999
   */
  public class BinarySearchNode 
  {
  
    // +--------+--------------------------------------------------
    // | Fields |
    // +--------+
  
    /** The key in the node (used for ordering the tree) . */
    Object key;
    /** The value stored in the node. */
    Object value;
    /** A linked structure of things smaller than this node. */
    BinarySearchNode smaller;
    /** A linked structure of things larger than this node. */
    BinarySearchNode larger;
  
    // +--------------+--------------------------------------------
    // | Constructors |
    // +--------------+
  
    /**
     * Build a single node in the tree.
     */
    public BinarySearchNode(Object key, Object value) {
      this.key = key;
      this.value = value;
    } // BinarySearchNode(Object,Object)
  
  } // class BinarySearchNode
  
  
  

• 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.
• For example,

  
  /**
   * A simple implementation of binary search trees.
   *
   * @author Samuel A. Rebelsky
   * @version 1.0 of November 1999
   */
  public class BinarySearchTree
    implements Dictionary
  {
    // +--------+--------------------------------------------------
    // | Fields |
    // +--------+
  
    /** The root of the binary search tree. */
    BinarySearchNode root;
  
    /** The comparator used to order the keys in the search tree. */
    Comparator compare;
  
    // +--------------+--------------------------------------------
    // | Constructors |
    // +--------------+
  
    /**
     * Build a new binary search tree whose nodes are ordered
     * by a particular comparator.
     */
    public BinarySearchTree(Comparator compare) {
      this.compare = compare;
      this.root = null;
    } // BinarySearchTree(Comparator)
  
    // +---------+-------------------------------------------------
    // | Methods |
    // +---------+
  
    /**
     * Find a value in the tree.
     */
    public Object get(Object key) 
      throws Exception
    {
      return get(root, key);
    } // get(Object)
  
    /**
     * Add a value to the tree.
     */
    public void put(Object key, Object value) 
      throws Exception
    {
      root = insert(root, key, value);
    } // put(Object)
  
    /**
     * Convert to a string for printing.
     */
    public String toString() {
      return toString(root, "");
    } // toString()
  
    // +---------+-------------------------------------------------
    // | Helpers |
    // +---------+
  
    /**
     * Find a value in a subtree.
     */
    public Object get(BinarySearchNode root, Object key) 
      throws Exception
    {
      // If the tree is empty, we're done.
      if (root == null) {
        throw new Exception("'" + key.toString() + "' is not in the tree");
      }
      // If the key is at the root, we're done
      else if (compare.equals(root.key, key)) {
        return root.value;
      }
      // If the key is smaller, try the left subtree
      else if (compare.lessThan(key, root.key)) {
        return get(root.smaller, key);
      }
      // If the key is larger, try the right subtree
      else {
        return get(root.larger, key);
      }
    } // get(BinarySearchNode, Object)
  
    /**
     * Insert a value into a node-based tree, updating the tree as
     * you go.
     */
    public BinarySearchNode insert(BinarySearchNode root, 
                                   Object key, Object value)
      throws Exception 
    {
      // To insert into the empty tree, make a new tree.
      if (root == null) {
        return new BinarySearchNode(key,value);
      }
      // If the keys are the same, update
      else if (compare.equals(root.key, key)) {
        root.value = value;
      }
      // If the key to be inserted is smaller, insert into the left subtree
      else if (compare.lessThan(key, root.key)) {
        root.smaller = insert(root.smaller, key, value);
      }
      // Otherwise, insert into the right subtree
      else {
        root.larger = insert(root.larger, key, value);
      }
      return root;
    } // insert(BinarySearchNode, Object, Object)
  
    /**
     * Convert to a simple, indented, string for printing.
     * Uses a multi-line representation, in which subtrees are further
     * indented.  Note that the "indent" parameter is used for indenting
     * subtrees, not the current tree.
     */
    public String toString(BinarySearchNode root, String indent) {
      if (root == null) return "*\n";
      else return root.value.toString() + "\n"
                  + indent + "  <-" + toString(root.smaller, indent + "  | ")
                  + indent + "  >-" + toString(root.larger, indent + "    ")
                  + indent + "\n";
    } // toString()
  } // class BinarySearchTree
  
  
  

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.