An array of lists

Question

A am with a group of students tasked with implimenting an array of linked lists to carry a set of integers (size unknown). We have a skeleton code to work from and will use some sort of hash function to find the cell that contains the list that an integer should be assigned to. There are two classes, the first is for the array and the hashing function and the second is the List class. We will be using a singly linked list and the integers will be kept in sorted order.
If for instance we are looking at the delete methods would something like the Following, inserted in the array class methods, Call upon the "List" class delete method for that particular array cell?
public void delete(int n) {
for OurListArray[ (some hash function) ] //my code
List.delete(n); //my code
If this was correct then I'd expect adding and finding and integer to be similar.
Does this make any sense?
Give me a clue so that I can try and proceed.

Answer 1

OK, this sounds similar to the kind of thing you might do for a Radix sort, or similar (which I don't know how to do off hand). But I can give you some clues about implementing a singly linked list.
Your List class, or interface will provide methods for adding, deleting, or traversing to a particular int. Somewhere you will probably want an additional class providing the concept of a List Node, encapsulating the value (int) and a pointer to the next Node in the list.
For example:
public class LinkedList {
     private Node head = null;
     private Node tail = head;
     public void addLast(int data) {
          tail.next = new Node(data, null);
          tail = tail.next;
     public void addFirst(int data) {
          head = new Node(data, head);
     // And so on...
     class Node {
          int data;
          Node next;
          public Node(int data, Node next) {
               this.data = data;
               this.next = next;
}You will probably want to put in delete / remove mechanisms as well, but remember that if you delete a node, you must handle the pointer in the preceding node, or you'll magically get it back whenever you traverse the list.
Traversal mechanisms would be best put in an Iterator, but this is not a trivial structure, so perhaps you could implement this simply by maintaining a cursor on the Node you are looking at.
Essentially, you need to be able to play with references easily - almost as if they are pointers in another language.
To summarise, you have a contolling List Implementation that hides the underlying Nodes to the user. You accomplish Node insertion and deletion by playing with the Node references, but all the user sees is ints.
I'm not sure if this helps any...