Class 32: Implementations of Lists

Held Wednesday, October 27, 1999

Overview

Today, we will continue our discussion of lists by considering techniques one might use for implementing lists.

Notes

• Some of you have expressed a desire to see the figures from C++ Plus Data Structures. There's a copy in the lab. I'll also try to make copies with the next chapter.
• Just in case you've forgotten, I drop the lowest exam grade. Hence, if you are unsatisfied with your grade on exam 2, you can always take the final. (If you're satisfied with your grades on all three exams, you won't have to take the final.)
• I've changed topics because of some difficulties you folks were having with getting the assignment done.
  • I would have preferred to have ``I don't understand the assignment'' questions earlier than the evening before the assignment was due.
  • We'll go over any questions you have now.
  • My expectations were (a) an interface for any of your classes that some other group might use; (b) a stub implementation for all of those classes; (c) compilable and ``working'' code.
  • Some of you wrote ``How do I write a stub class if I don't have access to other people's code?'' The point of stub classes is to eliminate calls to other code. Your stubs are simply simulations of what you expect your class to do.
• We had one important topic left to discuss about exam 2: the use of objects[i] vs. get(i) within your partition methods.
  • We'll consider reasons you might prefer one over the other.

Contents

• The Design of Lists, Revisited
  • Review
  • Three Kinds of Lists
• Implementing Lists
  • Implementing Lists with Arrays
    • Resizing Array-Based Lists
    • Gaps in the Array
    • Implementing Ordered Lists
  • Implementing Lists with Cons Cells

Handouts

Summary

• The design of lists, revisited
• Four kinds of lists: Scheme, Simple, Sequenced, Sorted
• Implementing lists with arrays
• Implementing lists with nodes

The Design of Lists, Revisited

Review

• Before break, we talked for some time about lists as data structures.
• Lists are mechanisms for organizing information in which the information is given in sequence and you can easily step through the information.
• What operations might we provide?
• The ``Scheme'' perspective suggests we need
  • Cons
  • Car
  • Cdr
  • Empty?
• The ``collection'' perspective suggests we need
  • Add
  • Remove (multiple versions)
  • Iterate through (using Reset, Next, and HasMoreElements)
  • Full?
  • ...
• Different computer scientists have different perspectives.
  • Some differences have to do with the sets of operations.
  • Some differences have to do with the meanings of operations.
• For example, where do we add an element?
• Similarly, what does remove do to the order of the list?
• We've also discussed the question of heterogeneous vs. homogeneous lists.

Three Kinds of Lists

• In Java Plus Data Structures, we decided to describe three kinds of collection-oriented lists
  • Simple lists make no guarantees on ordering
  • Sequenced lists guarantee that elements maintain their relative positions
  • Sorted lists give the impression that they elements are sorted
• We don't need any new operations; simply different meanings.
• For sequenced lists, we sometimes add new operations (e.g., for adding at the front or in the middle).

Implementing Lists

• We've thought about the various functionalities we might place in our various kinds of list classes.
• It is now time to consider how best to implement lists.
• There are two strategies for implementing lists:
  • You can store the elements in an array
  • You can allocate space for the elements dynamically, using things surprisingly like the cons cells you learned about in 151.
• We will consider each in turn, mostly working with simple lists.
• When we talk about implementation, we will (as usual) consider the four main parts of a class:
  • The fields
  • The constructors
  • The extractors
  • The modifiers

Implementing Lists with Arrays

• The fields:
  • An array of elements
  • The index of the next thing to add
  • The cursor (a current element for iteration)
  • The length
  • Possibly a comparison mechanism (for sorted lists)
• The constructors:
  • With an initial array size
  • With initial array size and default value?
    • Does that suggest that the list is full?
• Some questions
  • Can we do without the array size?
  • Are there other things we need?
  • Can we do without the length?
• The methods (think about preconditions and postconditions)
  • add
  • delete(Object o)
  • length
  • reset -- reset the cursor
  • nextElement -- get the next ``unseen'' element
  • hasMoreElements -- are there any more ``unseen'' elements?
  • ...
• More questions
  • Should we copy elements when assigning, or just copy references.
  • Others?
• Here's an untested implementation of simple lists in Java.

/**
 * The start of an implementation of Simple Lists, using arrays
 * as the underlying implementation structure.
 *
 * @author Samuel A. Rebelsky
 * @version 1.0 of March 1999
 */
public class ArrayBasedSimpleList
  implements SimpleList
{
  // +--------+--------------------------------------------------
  // | Fields |
  // +--------+

  /** The elements of the list. */
  protected Object[] elements;

  /** The cursor. */
  protected int cursor;

  /** 
   * The length of the list (different from the length of
   * the array).  Also used as the index of the next element
   * to add.
   */
  protected int length;

  // +--------------+--------------------------------------------
  // | Constructors |
  // +--------------+

  /** Create a new list of specified capacity. */
  public ArrayBasedSimpleList(int capacity) {
    elements = new Object[capacity];
    reset();
  } // ArrayBasedSimpleList(int)

  // +---------+-------------------------------------------------
  // | Methods |
  // +---------+

  /** 
   * Add an element to the list.  See the interface for
   * preconditions and postconditions.
   */
  public void add(Object element) {
    // Add the element.
    this.elements[this.length] = element;
    // Increase the length
    ++this.length;
  } // add(Object)

  /**
   * Delete an element from the list.  See the interface for
   * preconditions and postconditions.
   */
  public void delete(Object element) {
    // Step through the list until we find an equal element
    for (int i = 0; i < this.length; ++i) {
      // Note that we use element.equal because some
      // elements of the list may be null
      if (element.equals(this.elements[i])) {
        // Found it!  
        // Put the last thing here.
        this.elements[i] = this.elements[this.length-1];
        // Clear the last thing.
        this.elements[this.length-1] = null;
        // Update the length.
        --this.length;
        // And we're done.
        return;
      }
    } // for
    // Nope, didn't find it.  Nothing else to do.
  } // delete(Object)

  /**
   * Determine the length of the list.  See the interface
   * for preconditions and postconditions.
   */
  public int length() {
    return this.length;
  } // length()

  /**
   * Determine whether there is space available.  See the
   * interface for preconditions and postconditions.
   */
  public boolean spaceAvailable() {
    // There is space available if the length of the list is
    // less than the length of the array.
    return this.length < this.elements.length;
  } // spaceAvailable()

  /**
   * Reset iteration.  See the interface for preconditions and
   * postconditions.
   */
  public void reset() {
    this.cursor = 0;
  } // reset()

  /**
   * Get the next element.  See the interface for preconditions
   * and postconditions.
   */
  public Object nextElement() {
    // Note that it is possible to express this more concisely as
    //   return this.elements[this.cursor++];

    // Get the element to return.
    Object tmp = this.elements[this.cursor];
    // Advance the cursor.
    ++this.cursor;
    // Return the element.
    return tmp;
  } // nextElement()

  /**
   * Are there more elements left?  See the interface for preconditions
   * and postconditions.
   */
  public boolean hasMoreElements() {
    return this.cursor <= this.length;
  } // hasMoreElements()
} // class ArrayBasedSimpleList

Resizing Array-Based Lists

• What happens when you run out of space in the array?
  • Traditionally, you disallow the addition of new elements if the array has no space remaining.
• You might also create a new, bigger, array when you run out of space.
• Advantages:
  • Lists can keep expanding
  • You don't need to specify the maximum size of the list when you create it.
  • ...
• Disadvantages:
  • Inserting an element may no longer take constant time
  • May still run out of memory
  • ...

Gaps in the Array

• Rather than copying elements in when we delete, we might also leave ``gaps'' in the array by setting the deleted position to null.
• When we add an element, we might put it in the first space (or some space).
• When iterating, we need to skip over spaces.

Implementing Ordered Lists

• How does the implementation change for simple ordered lists (assuming we don't support ``gaps''?
  • The add method above adds in the proper place.
  • The iterator goes through the elements in a logical order.
  • So we just have to fix delete.
• The new delete needs to shift elements, rather than shoving the last element in the proper place.

    /**
     * Delete an element from the list.  See the interface for
     * preconditions and postconditions.
     */
    public void delete(Object element) {
      // Step through the list until we find an equal element
      for (int i = 0; i < this.length; ++i) {
        // Note that we use element.equal because some
        // elements of the list may be null
        if (element.equals(this.elements[i])) {
          // Found it!  
          // Shift everything down.
          for (int j = i; j < this.length-1; ++j) {
            this.elements[j] = this.elements[j+1];
          // Clear the last thing.
          this.elements[this.length-1] = null;
          // Update the length.
          --this.length;
          // And we're done.
          return;
        } // if found
      } // for
      // Nope, didn't find it.  Nothing else to do.
    } // delete(Object)
  

Implementing Lists with Cons Cells

• We can certainly implement lists using something like Cons cells.
• For example, here is an implementation of Cons cells for a Scheme-like list

  
  /**
   * A simple implementation of lists, similar to the lists provided
   * by languages like Scheme and LISP.  Created as an example for
   * CSC152.  Based on the incredibly-similar ConsCell (Samuel
   * A. Rebelsky. ConsCells.java.  Version 1.0 of October 1999.
   * Found on the Web at 
   *   {$site_url}/Examples/ConsCell.java
   * Accessed 27 October 1999.)
   *
   * @author Samuel A. Rebelsky
   * @version 1.0 of October 1999
   */
  public class ConsCell {
    // +--------+--------------------------------------------------
    // | Fields |
    // +--------+
  
    /** The first element in the list. */
    protected Object head;
  
    /** 
     * The remainder of the list. Set to null when there are
     * no more elements in the list.
     */
    protected ConsCell tail;
  
    // +--------------+--------------------------------------------
    // | Constructors |
    // +--------------+
  
    /** Build a new list with specified head and tail. */
    public ConsCell(Object head, ConsCell tail) {
      this.head = head;
      this.tail = tail;
    } // ConsCell(Object, ConsCell)
  
    // +-----------------------------------------------------------
    // | Extractors |
    // +------------+
  
    /**
     * Get the head of the list.
     * Pre: The list is initialized and nonempty.
     * Post: Returns the first element of the list.
     * Post: Does not modify the list.
     */
    public Object head() {
      return this.head;
    } // head()
  
    /**
     * Get the tail of the list.
     * Pre: The list is initialized and nonempty.
     * Post: Returns all but the first element of the list (as a list).
     * Post: Does not modify the list.
     */
    public ConsCell tail() {
      return this.tail;
    } // tail()
  
    // +-----------+-----------------------------------------------
    // | Modifiers |
    // +-----------+
  
    /**
     * Set the first element of the list to newHead.
     * Pre: The list is initialized.
     * Post: Subsequent calls to head return newHead (until the
     *   head is updated again).
     * Post: The remainder of the list is not modified.
     */
    public void setHead(Object newHead) {
      this.head = newHead;
    } // setHead(Object)
  
    /**
     * Set the remainder of the list to newTail.
     * Pre: The list is initialized.
     * Post: Subsequent calls to tail return newTail (until the
     *   tail is updated again).
     * Post: The head of the list is not modified.
     */
    public void setTail(ConsCell newTail) {
      this.head = newTail;
    } // setTail(ConsCell)
  
  } // class ConsCell
  
  
  

• But this class doesn't provide the same functionality as those listed above. What do we do? We'll see in class tomorrow.