Class 35: Adding Elements to Linked Lists

Held Wednesday, April 5, 2000

Overview

Today we continue to consider a node-based implementation of simple lists.

Notes

• I've rearranged the past few outlines to better match what we actually covered.
  • Outline 31: Array-based Lists
  • Outline 33: Exam 2
  • Outline 34: Scheme Lists
• I encourage those of you who are second year students (Ammar, MnMs, Mustally, Mark, Elizabeth, Katt, Hisako) to consider declaraing a computer science major.
  • No matter what major you declare, you need to work out a four-year plan and write a short essay on your version of the liberal arts education.
  • When you write the essay, be sure to reflect on the college's statement about liberal arts education (found on pp. 31-33 of the catalog).
• Assignment 4 is now ready.

Contents

• Review: SimpleLinkedLists
• Separate List Cursors

Summary

• Linked list implementation, revisited
• Special cases for adding elements
• Different positions for adding elements

Review: SimpleLinkedLists

• In yesterday's class, we talked about how we might implement simple lists using the ConsCells that are essential to Scheme-like lists.
• Such lists are often called linked lists.
• Here's what we have so far

  /**
   * An implementation of simple list usings linked
   * nodes.  Each node contains a link to the next
   * element of the list.  This version still lacks
   * delete methods.
   *
   * @author Samuel A. Rebelsky
   * @author The Students of CSC152 2000S
   * @version 0.1 of April 2000
   */
  public class SimpleLinkedList 
    implements SimpleList
  {
    // +--------+-----------------------------------------
    // | Fields |
    // +--------+
    
    /** 
     * The first element of the list.  All other elements are
     * reachable from this element.  This element is set to null
     * if the list is empty.
     */
    protected ConsCell front;
  
    /**
     * The last element of the list.  Useful when we want to
     * quickly add to the end of the list.
     */
    protected ConsCell back;
  
    /**
     * The current element of the list.  Used for iteration.
     */
    protected ConsCell current;
  
    // +--------------+-----------------------------------
    // | Constructors |
    // +--------------+
  
    /**
     * Create a new empty list.
     */
    public SimpleLinkedList() {
      front = null;
      back = null;
      current = null;
    }
    
    // +----------------------+---------------------------
    // | Iteration Operations |
    // +----------------------+
  
    public Object getCurrent() {
      return current.getContents();
    } // getCurrent()
  
    public void advanceCurrent() {
      current = current.cdr();
    }
  
    public void reset() {
      current = front;
    }
  
    // +-----------+----------=---------------------------
    // | Modifiers |
    // +-----------+
  
    // Needs work!
    public void add(Object something) {
      // Create a new cell to hold the thing.
      ConsCell newCell = new ConsCell(something, null);
      // Put it after the last element
      back.setNext(newCell);
      // Make it the new last element.
      back = newCell;
    } // add(Object)
  
  } // class SimpleLinkedList
  

• What else do we need to do to implement add?
• How would we implement addAfterCurrent?
• How would we implement delete?
• How would we implement retreatCurrent?

Separate List Cursors

• A disadvantage of our implementation is that there is only one cursor per list.
• Some computer scientists advocate having multiple cursors per lists, with the cursors treated as separate objects.
• ...