Outline of Class 24: Implementing Lists

Miscellaneous

• As I mentioned earlier, I've been spending this week working on the rough draft of a grant proposal. The intent of the grant is to provide multimedia-based examples in 103, 151, 152, and 153. I'd appreciate your comments on my sample exercise: one on cut detection and one on facial distortion.
• No more assignments before break. Yay!
• Any questions on the readings?

Singly-Linked Lists

• There are a number of ways to implement lists, including using other data structures to implement them.
• However, the most basic implementation is the singly-linked list, in which a list is represented as a series of nodes, each of which has a single link to the next element in the list.
• As a Java class,

  /**
   * Nodes for a singly-linked list.
   */
  public class Node {
    /** The value in the current node.  A value of null
     * indicates (...)
     */
    protected Object value;
    /** The next node in the list.  A value of null
     * indicates that this is the last element of the list.
     */
    protected Node next;
    ...
  } // Node
  

• We use a special value, null, for links from nodes that have no next element.
  • Alternatively, you can think of null as representing a "non node".
• We then wrap our nodes in a separate list class. Why? So that it's easier to handle issues like insertion and removal.
  • However, this can make it harder to write methods like tail, which now needs to create new list objects.
  • Scheme lists do not have this separate wrapper class for just this reason.
• If you're using a wrapper class, you can also include a number of other fields, such as a link to the current element of the list and a link to the end of the list.
• For our purposes, we can assume the following definition

  /**
   * A singly-linked list.
   */
  public class List {
    /** The elements of the list, starting at the front */
    protected Node front;
    /** The last element of the list. */
    protected Node back;
    /** The current element of the list. */
    protected Node current;
    ...
  } // List
  

Head and Tail

• The two most primitive operations on lists are getting the head (first element) and tail (all but first element).
• The implementation of these two operations depends on your implementation of lists: are you using just nodes, or are you also using a wrapper class?
• If you're just using nodes, the definitions are relatively straightforward, and just return the appropriate fields.

  /**
   * Return the first element in a list.
   * pre: The list is nonempty.
   * post: The first element is returned.
   */
  public Object head() {
    return value;
  } // head
  /**
   * Return all but the first element in the lsit.
   * pre: The list is nonempty.
   * post: The list containing all but the first element is
   *   returned.
   * post: The two lists share nodes, so modifications to one
   *   may affect the other.
   */
  public Node tail() {
    return next;
  } // head
  

• For the wrapper-based version, head is also relatively straightforward

  /**
   * Return the first element in a list.
   * pre: The list is nonempty.
   * post: The first element is returned.
   */
  public Object head() throws ListException {
    // Sanity check
    if (front == null) {
      throw new ListException("Can't take the head of an empty list.");
    }
    else {
      return front.head();
    }
  } // head
  

• Unfortunately, tail is much more complicated, as it requires us to build a new structure, and to consider the implications of combining tail with other operations on the returned list. (This is likely why our book doesn't provide a tail operation.)
• Here is one possible implementation

  /**
   * Return all but the first element in the lsit.
   * pre: The list is nonempty.
   * post: The list containing all but the first element is
   *   returned.
   * post: The two lists do not share nodes, so they may
   *   be modified independently.
   * post: The current element of the new list is the first
   *   element of that list.
   */
  public List tail() throws ListException {
    // Sanity check
    if (front == null) {
      throw new ListException("Can't take the tail of an empty list.");
    }
    // Standard implementation
    else {
      // Make a new list
      List my_tail = new List();
      my_tail.front = front.next().clone();
      my_tail.back = figureOutWhereTheBackIs();
      my_tail.current = my_tail.front; // As good as anywhere else
    }
  } // tail