Science Computer 225
Laboratory Assignment #3
Spring 2006
DUE DATE: 6 April, 2006
LEARNING OBJECTIVES: In completing this assignment, each student will learn how to manipulate simple linked data structures. get experience implementing iterators. DESCRIPTION: The above objective will be realized using a simple type of linked list called a self organizing list which tends to keep the most frequently referenced elements near the front of the list. Under certain conditions, the operations on a long list might have reasonable expected performance (there are generally much better approaches, however). The following interface is provided as the basis for a class SOList. Your class must implement the following interface in creating and manipulating this special type linked list. Your list iterator should be a fail fast iterator.
import java.util.Iterator; /** * This interface provides an abstraction for a self-organizing * list which has the following properties: * -- Additions are made to the front of the list. * -- If a "find" operation succeeds, the associated * element is placed at the front of the list; * the order of the remaining elements does not change. */ public interface SOListInterface<T> { /** * The following method should add the new element * to the front of the list. * * @param obj -- the data object to be added. */ public void add(T obj);
/** * Returns the first element from the list. * * @returns the data object from the first cell. * @throws NoSuchElementException if the list is empty. */ public T get();
/** * The remove() method removes the first element * of the list. This method normally follows * an application of a successful find operation. * * @return the data member associated with the * first cell. * @throws NoSuchElementException if the list * is empty. */ public T remove(); /** * The following method returns the data member * of a cell or null if the object is not in * the list. If present, the method moves the * the cell to the front of the list before * returning the value. * * @param obj -- the data value to match (via * equals). */ public T find(T obj);
/** * Returns the number of elements in the list. */ public int size();
/** * The iterator() method returns an Iterator. * * @return an Iterator for the list. * */ public Iterator<T> iterator(); }
Copy the les SOListInterface.java and SOListTester.java from the assignment directory (~stark/cs225/prog3) and implement the above interface. In addition, you are to implement the Cloneable interface and provide a clone() method which does a shallow copy (it does not attempt to clone the data members). implement the cell structure of your linked list (should be singly linked) using a private inner class Node. override the toString() method to return a string representation of the contents the of elements in the list. If elem1 is the rst element in the list, elem2 is the second element, and so on, then the string that toString returns should be constructed as follows:
elem1.toString() + "\n" + elem2.toString() + "\n" + ... + elemN.toString() + "\n"
where elemN is the last element in the list. Do NOT put any other characters in this string, as we will be using a string comparison to insure that your program has everything in the correct order.
Grading Issues
Unlike the previous two assignments, style and documentation will be a signicant portion in the grading of this assignment. Refer to the Style Guide for further information. Submit your program from onyx from a directory containing only the relevant les using: submit stark cs225 3
Suggestions
As noted above, you will need a Node class to represent the list nodes, which needs to be a private class dened inside your SOList class. Besides privacy, structure, and encapsulation, there is an important reason to do it this way: inside the SOList<T> class the parameterized type T is known. Because of this, elds of the internal Node class can have type T, but the Node class itself does not have to be (and should not be) generic. In fact, if you do something like
class Node<T> { ... }
that T actually refers to a different generic type than that of the SOList class! For the iterator, you will need a second (private) interior class that implements the Iterator interface. In particular it must implement the hasNext, next, and remove methods. Dont be surprised if it takes you longer to implement this iterator than all the other methods in the SOList. As with your Node class, ...