CS 307Assignment, Linked Lists

Programming Assignment 8: This is an individual assignment. You must complete this assignment on your own. You may not discuss their work with anyone except the instructor and other members of the instructional staff (TA, section leader, or lab proctor). You may not acquire, from any source (e.g., another student or an internet site), a partial or complete solution to a problem or project that has been assigned. You may not show another student your solution to an assignment. You may not have another person (current student, former student, tutor, friend, anyone) “walk you through” how to solve an assignment. Review the class policy on collaboration from the syllabus.

Placed online: Friday, July 30
20 points, ~2% of total grade
Due: no later than 11 pm, Monday, August  9
General Assignment Requirements

Description:  The purposes of this assignment are to:

1. implement an abstract data type using Java's generic syntax.
2. work with linked data structures
3. implement an iterator

In this assignment you will be implemented a linked list that uses doubly linked nodes. In class most of our examples were a list with singly linked nodes. Doubly linked nodes have references (pointers) to the next node in the list and back to the previous node in the list. This makes some things harder because there are more references (pointers) to set up. But, it makes a lot of things easier because now it is possible to back up in the list without having to start over at the beginning, use the look ahead technique, or use a trailer node.

Provided Files:

DoubleListNode provides code for a doubly linked list node. (Alternatively you can add a nested class to the LinkedList class for the doubly linked nodes as demonstrated in lecture. None of the test cases will reference the DoubleListNode class.)

IList provides the interface for for a List abstract data type. Do not alter this interface.

LinkedList implements the IList interface. Complete this class under the restrictions of the general assignment requirements. For this assignment you may not use the LinkedList or ArrayList classes from the Java standard library. You must implement the underlying storage container as a doubly linked structure using the DoubleListNode class. The DoubleListNodes and LinkedList are generic based on Java's generic syntax.

LinkedListTester provides some tests for the LinkedList class. Some of these tests may be incorrect. Find and fix any incorrect tests. Your class must pass these (corrected) tests. Add at least 3 tests of your own per method in the LinkedList class to the LinkedListTester class. Use the class listserv to discuss which tests are in error and how to correct. Post the tests you write to the class listserv. Note, most of my tests rely on your iterator method. If that is not working you will fail the tests. I strongly recommend you test your methods as you complete them by writing your own tests! Write a method, then test it. Write a method, then test it. DON'T do this:  write a method, write a method, write a method, ... then test ...then debug, debug, debug, debug, debug, debug.

Implementation details: In this assignment you will implement a list class using a doubly linked structure as the internal storage container. You may approach the implementation in many ways. (References to first and last node, circular list with only a link to the first node, use of dummy nodes or not.) The approach you take is up to you. Each has certain advantages and disadvantages.

In addition to implementing the methods specified in the IList interface you must add  the following methods to the LinkedList class. E is the data type variable. It will hold what the data type is for the elements (thus the E) of a particular LinkedList object.

• void addFirst(E item) // add an item to the front of this LinkedList
• void addLast(E item) // add an item to the end of this LinkedList
• E removeFirst() // remove the first item in this LinkedList
• E removeLast() // remove the first item in this LinkedList
• override the toString method. The data in the list should be listed between square brackets with a comma between each item and a single space after each comma. e.g. [A, B, C]
  public String toString()
• override the equals method. Two lists are equal if they have the same number of elements in the same order.
  public boolean equals(Object other)

For each and every method in the LinkedList class state the Big O of the method if there are already N items in the list.

You can, of course, implement methods in using of other methods from the class. You should only do this if the version of a method that relies on other methods in the class is as efficient as not using other methods.

Experiments: It is interesting and important to know the difference in behavior between linked lists and array based lists. When your LinkedList class is finished, run the comparison method from the LinkedListTester class which performs a number of tests between your LinkedList and the Java ArrayList class. In a comment at the top of your LinkedListTester class indicate which operations are faster when using your LinkedList, which are faster when using the Java ArrayList class, and which ones are about the same regardless of which list is used.

When finished turn in your LinkedList.java and LinkedListTester.java classes using the turnin program. (No jar this time.)

Checklist:  Did you remember to:

• review and follow the general assignment requirements?
• work on the assignment individually?
• fill in the header in LinkeListTester.java?
• ensure each method in your LinkedList class states the Big O of the method in the method comment?
• ensure your version of LinkedList passes the tests in LinkedListTester.java and add your own tests?
• ensure your program does not suffer a compile error or runtime error?
• turn in your Java source code files to the proper account in the Microlab via the turnin program before 11 pm, Monday, August 9?

Tips: Draw pictures!! When completing methods and figuring out all the references that have to be updated and what the special cases are DRAW PICTURES of the linked structure. This is much easier than just looking at code and trying to figure out what must be done or why something does not work.

The Iterator. The IList interface calls for a method named iterator. This method returns an object of type Iterator that can be used to traverse efficiently through the elements of the list in order. Without the iterator the only way to traverse the list is via N calls to get and that would have a Big O of N^2, (N calls to get, an efficient get does an average of N/4 steps per call to get the specified item). In order to implement the iterator and not make the data members of the LinkedList class public you will make it an inner class. Inner classes are defined as follows:

public class LinkedList<E> implements IList<E>{
    //code for LinkedList class

    private class LLIterator implements Iterator<E>{
        // There is no <E> after LLIterator because E is already
        // defined in the outer class, LinkedList

        //code for the LLIterator class
    }

}

Inside the LLIterator class you must define all the methods from the Iterator interface. As an inner class, LLIterator will have access to the private data members of the LinkedList class. For this assignment you must implement a working version of the remove method from the Iterator interface.

If you wish to use the remove method from the LinkedList class in the Iterator remove method, there is a conflict with naming. You have to use the following syntax.

//in LLIterator's remove method
LinkedList.this.remove( blah );

Realize you can and should implement the iterator remove method much more efficiently, O(1), than the LinkedList's remove method. It is also simpler to implement the iterator remove method with doubly linked nodes than it was with singly linked nodes.

  Back to the CS 307 homepage.