排序的基于链接的列表Java

Question

I'm working on an assignment for my Data Structures class. We have to create an address book using our own sorted linked based list adt. Right now the add method works, but it seems to make all the nodes point to the first node. Whenever I try to output the the list using getEntry() in a for loop, it gives me the last added entry each time. I've tried using toArray but it does the same thing. Can you see any problems?

public class GTSortedLinkedBasedList implements GTListADTInterface {
private Node firstNode;
private int  numberOfEntries;

public GTSortedLinkedBasedList(){
    //firstNode = new Node(null);
    numberOfEntries = 0;
}

public void setNumberOfEntries(int x){
    numberOfEntries = x;
}

public void add(ExtPersonType newEntry){
   //firstNode = null;
   Node newNode = new Node(newEntry);
   Node nodeBefore = getNodeBefore(newEntry);
   if (isEmpty() || (nodeBefore == null))
   {
      // Add at beginning
      newNode.setNextNode(firstNode);
      firstNode = newNode;
   }
   else
   {
      // Add after nodeBefore
      Node nodeAfter = nodeBefore.getNextNode();
      newNode.setNextNode(nodeAfter);
      nodeBefore.setNextNode(newNode);
   } // end if
   numberOfEntries++;
}

private Node getNodeBefore(ExtPersonType anEntry){
    Node currentNode = getFirstNode();
    Node nodeBefore = null;
    while ((currentNode != null) &&
    (anEntry.getFirstName().compareTo(currentNode.getData().getFirstName()) > 0))
    {
    nodeBefore = currentNode;
    currentNode = currentNode.getNextNode();
    } // end while
    return nodeBefore;
}

private class Node {

    private ExtPersonType data;
    private Node next;

    public Node(ExtPersonType dataValue) {
        next = null;
        data = dataValue;
    }

    public Node(ExtPersonType dataValue, Node nextValue) {
        next = nextValue;
        data = dataValue;
    }

    public ExtPersonType getData(){
        return data;
    }
    public void setData(ExtPersonType newData){
        data = newData;
    }
    public Node getNextNode(){
        return next;
    }
    public void setNextNode(Node newNode){
        next = newNode;
    }

}


public ExtPersonType getEntry(int givenPosition) {
    if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)){
      assert !isEmpty();
      return getNodeAt(givenPosition).getData();
   }
   else{
      throw new IndexOutOfBoundsException("Illegal position given to getEntry operation.");
   }
}

public void loadData(GTSortedLinkedBasedList contacts) throws FileNotFoundException{
    //int index = 0;
    ExtPersonType person = new ExtPersonType();
    DateType tempDate = new DateType();
    AddressType tempAddress = new AddressType();
    Scanner file = new Scanner(new FileInputStream("Programming Assignment 1 Data.txt"));
    while(file.hasNext()){
        person.setFirstName(file.next());
        person.setLastName(file.next());
        tempDate.setMonth(file.nextInt());
        tempDate.setDay(file.nextInt());
        tempDate.setYear(file.nextInt());
        person.setDOB(tempDate);
        tempAddress.setStreetAddress(file.nextLine());
        if(tempAddress.getStreetAddress().isEmpty()){
            tempAddress.setStreetAddress(file.nextLine());
        }
        tempAddress.setCity(file.nextLine());
        tempAddress.setState(file.nextLine());
        tempAddress.setZipCode(file.nextLine());
        person.setAddress(tempAddress);
        person.setPhoneNumber(file.nextLine());
        person.setPersonStatus(file.nextLine());
        if(person.getPersonStatus().isEmpty()){
            person.setPersonStatus(file.nextLine());
        }
        contacts.add(person);
        System.out.println(contacts.getEntry(contacts.getLength()).getFirstName());
        //index++;

    }
}

public static void main(String[] args) throws FileNotFoundException {
    AddressBook ab = new AddressBook();

    ab.loadData(ab);
   ExtPersonType people = new ExtPersonType();
    //people = ab.toArray(people);
    System.out.println(ab.getLength());
    for(int cnt = 1; cnt <= ab.getLength(); cnt++){
        people = ab.getEntry(cnt);
        System.out.println(people.getFirstName());
    }

}

EDIT: The add method is overwriting each previous object with the newly added one. It also doesn't seem to matter if I do a sorted list or just a basic list.

Answer 1

I'm not going to lie here, I'm not totally sure I understand your code but I think I see what's wrong. In your getNodeBefore() method's code, you set currentNode() always to firstNode(). I believe that is causing the problem. I see that you are trying to recursively move through the list to find the proper node but I don't think each recursive call is causing movement through the list. I suggest you add properties to the object that represent the forward and backward nodes.

Something like this...

private T data;
private Node nodeBefore;
private Node nodeAfter;

As you create objects, you assign the properties before and after and then all the information you need is contained in the object itself.

To move recursively through the list you would then just add a statement like currentNode = currentNode.nodeAfter.

Your getNodeBefore() method would simply return currentNode.nodeBefore and getNodeAfter() would return currentNode.nodeAfter.

Answer 2

You don't have code that handles the situation where the node being added will be the first node in the list, but the list is also not empty. In this case, getNodeBefore returns null, and your code overwrites the root node.

Try

   if (isEmpty() && (nodeBefore == null))
   {
     // Add at beginning
     newNode.setNextNode(firstNode);
     firstNode = newNode;
   }
   else if(nodeBefore == null)
   {
     Node temp = new Node();
     temp.setNextNode(first.next);
     temp.setData(first.data);
     newNode.setNextNode(temp);
     firstNode = newNode;
   }