CSC-152 99S : Class 30: Object-Oriented design

The converse of insertion is deletion. We will frequently need to delete elements from our list.

As with most list-based functions, there are a number of varieties of deletion.

We might delete the head of a list.
We might delete the last element of a list.
We might delete the current element of a list.
We might delete all instances of a particular object.
We might delete the first instance of a particular object.

Our implementation of deletion also depends on how we are representing lists (with a wrapper class, or just with the Node class).

Using our standard the wrapper class, deletion at the head is relatively easy: we just update the front to the thing next to the front.

  /**
   * Delete the first element in the list, returning that element.
   * pre: the list is initialized and nonempty.
   * post: the list is one element smaller and no longer
   *   contains the previous head element.
   * post: returns the deleted item.
   */
  public Object deleteHead() 
    throws Exception 
  {
    Node deleted = front;
    // Update the front
    front = front.nextNode();
    // Update current, if necessary. == is the appropriate comparison
    // operation since we want to make sure that we're referring to 
    // the same node, and not just two nodes with the same contents.
    if (current == deleted) {
       current = front;
    }
    // Return the front element
    return deleted.contents();
  } // deleteHead()

Note that while I've used methods of my Node class, it would also be reasonable to directly access Node's fields, since these are related classes, and would be in the same package.

Note also that I did not verify that the list is nonempty. That's because it's a precondition of the method.

Deletion from the end of a list is more difficult, as you need to step through until you are ``two back'' from the end of the list.

  /**
   * Delete the last element in the list, returning that element.
   * pre: the list is nonempty
   * post: the list is one element smaller and no longer
   *   contains the previous final element
   * post: if the current element was the final element, the
   *   current element is now the first element.
   */
  public Object deleteLast() throws ListException {
    // The element we're about to delete
    Node deleted;
    // Special case: the list has one element
    if (front.next == null) {
      deleted = front;
      front = null;
      current = null;
      back = null;
      return deleted.contents();
    } // only one element
    // Standard case: the list has at least two elements
    else {
      // The element we're currently looking at
      Object pointer = front;
      // The element we're about to delete
      Object 
      // Keep going until we reach the last node
      while (pointer.nextNode().nextNode() != null) {
        pointer = pointer.nextNode();
      } // while
      // We're now one step back from the end, so delete
      // the next element. 
      deleted = pointer.next;
      pointer.next = null;
      // Update the current element if necessary.
      if (current == deleted) { 
        current = front; 
      }
      // Return the element
      return deleted.contents();
    } // List of length two or more
  } // deleteLast

Deleting all copies of a particular element can be somewhat more difficult, since it may require an even more sophisticated version of the ``double next'' pointer strategy used above.

Consider what happens if subsequent elements need to be deleted.

However, we can simplify our implementation by using a recursive Node-based deletion.

Here are the two related functions

  /**
   * Delete all copies of an element from a sequence of Nodes.
   */
  public Node deleteCopies(Node list, Object element) {
    // Base case: empty list
    if (list == null) {
      return null;
    }
    // The head of the list contains the element.  Delete and
    // recurse
    else if (list.contents().equals(element)) {
      return deleteCopies(list.tail(), element);
    }
    // The head of the list doesn't contain the element.  Work on
    // the tail.
    else {
       list.setNext(deleteCopies(list.tail(), element));
       return list;
    }
  } // deleteCopies
   
  /**
   * Delete all copies of an element from a list.
   * See the exam for comments.
   */
  public void deleteCopies(element) {
    front = deleteCopies(front,element);
    // Fix current element if necessary
    if (current.contents().equals(element)) current = front;
    // Recompute the last element if necessary
    if (back.contents().equals(element)) recomputeBack();
  } // deleteCopies

Class 30: Object-Oriented design

Linked Lists, Continued

Deletion from Linked Lists

Iteration

Object-Oriented Design

Techniques for object-oriented design

An example: Online auctions