Outline of Class 26: More on Lists; Introduction to Representation

Miscellaneous

• This has not been a good month for getting grading done. If you check out my todo list, you'll see why. You may have to wait until late Wednesday, but everything should be graded by then.
• There are a number of readings for Wednesday
  • An online reading on Machine-level data types
  • An online reading on IEEE Representation of floating point numbers.
  • Some handouts on arithmetic representation by P.J. Plauger.

Doubly-Linked Lists

• The wrapper-based implementation of singly-linked lists presents some implementation difficulties, particularly for operations like deleteCurrent and deleteLast.
• One way to simplify these operations is to add a previous link to each Node, so that you can move both backwards and forwards along the list.
• Note that this is yet another instance of symmetry as a guiding principle.
• (Although we make this modification directly to our Node class, you generally want to use doubly-linked lists only with a wrapper class.)
• How does the previous link help? Well, when deleting an element, all you have to do is switch the next link of the previous element and the previous link of the next element.

Deletion from a double-linked list

• To delete a particular element, all you need to do is make the next and previous element "refer to" each other, as in the following method of the modified Node class.

  /**
   * Delete the current node from a sequence of nodes.
   * pre: This node is defined/initialized
   * post: This node is no longer referred to by the previous and
   *   next nodes.
   */
  public void deleteMe() {
    if (previous != null) {
      previous.next = next;
    } // if there is a previous element
    if (next != null) {
      next.previous = previous;
    } // if there is a next element
  } // deleteMe
  

• Observe that this greatly simpliflies the deletion operations. Here are versions of the various deletion operations for the wrapper-based List class. You can fill in appropriate pre- and post-conditions.

  public Object deleteCurrent() throws ListException {
    if (current == null) {
      throw new ListException("Can't determine current element");
    }
    else if (front == null) {
      throw new ListException("Can't delete elements from empty list");
    }
    else {
      Node deleted = current;
      current.deleteMe();
      if (current.nextElement() == null)
        current = front;
      else
        current = current.nextElement();
      return deleted.contents();
    }
  } // deleteCurrent
   
  public Object deleteLast() throws ListException {
    if (front == null) {
      throw new ListException("Can't delete elements from empty list");
    }
    else {
      Node deleted = back;
      back.deleteMe();
      back= back.previous;
      return deleted.contents();
    }
  } // deleteLast
   
  public Object deleteCopies(Object element) {
    // Delete all copies by stepping through the list
    for(Node pointer = front;
        pointer != null;
        pointer = pointer.nextElement()) {
      if (pointer.contents().equals(element)) {
        pointer.deleteMe();
      }
    } // for
    // Update current and back if necessary
    if (current.contents().equals(element)) current = front;
    if (back.contents().equals(element)) computeBack();
  } // deleteCopies
   
  

• This significantly improves the efficiency of these operations. For example, deleteLast now takes constant time, rather than time linear in the size of the structure.

Problems with double-linked list

• Although doubly-linked lists simplify some operations (such as deletion), they may also compilicate others (such as insertion), since you now need to worry about other references.
• In addition, with doubly-linked lists, it is no longer possible to reuse portions of a list in multiple lists (otherwise, you'd need multiple previous references).
• Some find this a positive change, since it is no longer possible for a modification to one list to affect another list.

Implementing Lists with Arrays