java 循环双链表列表迭代器

这是一个家庭作业问题。我有一个Double Linked Node类，一个实现Iterable的Circular Double Linked List类，以及一个实现Iterator的Iterator类。我理解迭代器的概念，其中隐式游标位于两个节点之间，在调用next()时，它返回它刚刚跳过的节点。我用一个新的list对象创建了一个测试类。然后我创建了一个迭代器并调用next，我收到了正确的No Such Element exception，但是当我向列表中添加一些节点时，我收到了Null Pointer Exception，而不是返回最后返回的节点。我该如何纠正？
我的节点类：

public class DoubleLinkedNode<E>{
private E data;

private DoubleLinkedNode<E> next;

private DoubleLinkedNode<E> prev;

public DoubleLinkedNode(E data, DoubleLinkedNode<E> next, DoubleLinkedNode<E> prev){
    this.data = data;
    this.next = next;
    this.prev = prev;
}
/**
 * Used to construct a node that points to null for its prev and next.
 * @param data Data is a generic variable to be stored in the node.
 */
public DoubleLinkedNode(E data){
    this(data, null, null);
} 

//getters
public E getData(){
    return data;
}

public DoubleLinkedNode<E> getNext(){
    return next;
}

public DoubleLinkedNode<E> getPrev(){
    return prev;
}
//setters
public void setData(E data){
    this.data = data;
}

public void setNext(DoubleLinkedNode<E> next){
    this.next = next;
}

public void setPrev(DoubleLinkedNode<E> prev){
    this.prev = prev;
}

@Override public String toString(){
    if(data == null){
        return null;
    }
    else{
        return data.toString();
    }
}

}

List类与私有内部Iterator类：

import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;

public class CircularDoubleLinkedList<E> implements Iterable<E>{

private int size;   
private DoubleLinkedNode<E> head;

public CircularDoubleLinkedList(){
    this.head = null;
    this.size = 0;      
}       
/**
 * Adds an item to the end of the list.
 * 
 * @param data The Data that is to be stored in the node.
 */ 
public void add(E data){    
    DoubleLinkedNode<E> newNode = new DoubleLinkedNode<E>(data);
    if(this.head == null){
        newNode.setNext(newNode);
        newNode.setPrev(newNode);
        this.head = newNode;
        this.size++;
        //if list is empty create a new node and insert
    }
    else{
        DoubleLinkedNode<E> temp = this.head.getPrev();
        this.head.getPrev().setNext(newNode);
        this.head.setPrev(newNode);
        newNode.setPrev(temp);
        newNode.setNext(this.head);     
        this.size++;
    }
}
/**
 * Which adds an item at the specified index.
 * 
 * @param index The index in which the new Node is added. 
 * @param data The data which is to be stored in the node.
 */
public void add(int index, E data){
    int currIndex = 0;
    DoubleLinkedNode<E> currNode = this.head;
    DoubleLinkedNode<E> nextNode = this.head.getNext();
    DoubleLinkedNode<E> prevNode = this.head.getPrev();
    DoubleLinkedNode<E> newNode = new DoubleLinkedNode<E>(data);
    if(index == 0){
        prevNode.setNext(newNode);
        currNode.setPrev(newNode);
        newNode.setPrev(prevNode);
        newNode.setNext(currNode);
        this.head = newNode;
        this.size++;    
    }
    else if (index > 0){        
        while(currIndex != this.size){
            if(currIndex != index%size){
                currIndex++;
                currNode = currNode.getNext();
                nextNode = nextNode.getNext();
                prevNode = prevNode.getNext();                  
            }else{              
                newNode.setPrev(prevNode);
                newNode.setNext(currNode);
                prevNode.setNext(newNode);
                currNode.setPrev(newNode);
                currNode = newNode;
                this.size++;
                break;                                      
            }
        }       
    }
    else if (index < 0){
        while(currIndex != -this.size){
            if(currIndex != index%size){
                currIndex--;
                currNode = currNode.getPrev();
                prevNode = prevNode.getPrev();
                nextNode = nextNode.getPrev();
            }else{              
                newNode.setNext(nextNode);
                newNode.setPrev(currNode);
                currNode.setNext(newNode);
                nextNode.setPrev(newNode);          
                currNode = newNode;
                this.size++;
                break;                                      
            }
        }   
    }
}
/**
 * Returns the data stored at the specified index.
 * 
 * @param index The index determines the node whose data is returned.
 * @return Returns the data of the node at the index.
 */
public E get(int index){//returns the data stored at the specified index
    int currIndex = 0;
    DoubleLinkedNode<E> currNode = this.head;
    E temp = null;      
    if(index == 0){//zero case          
        temp = currNode.getData();
    }
    else if(index > 0){//positive           
        while(currIndex != this.size){
            if(currIndex != index%size){
                currIndex++;
                currNode = currNode.getNext();                              
            }else{                              
                temp = currNode.getData();
                break;                                      
            }
        }   
    }
    else if(index < 0){//negative       
        while(currIndex != -this.size){
            if(currIndex != index%size){
                currIndex--;
                currNode = currNode.getPrev();
            }else{              
                temp = currNode.getData();
                break;                                      
            }
        }           
    }
    return temp;
}   
/**
 * Which removes and returns an item from the list.
 * 
 * @param index Removes the node at the current index.
 * @return Returns the data of the removed node.
 */
public E remove(int index){//which removes and returns an item from the list
    int currIndex = 0;
    DoubleLinkedNode<E> currNode = this.head;
    DoubleLinkedNode<E> nextNode = this.head.getNext();
    DoubleLinkedNode<E> prevNode = this.head.getPrev();
    E temp = null;  
    if(index == 0){
        temp = currNode.getData();
        prevNode.setNext(currNode.getNext());
        nextNode.setPrev(currNode.getPrev());
        this.head = nextNode;
        size--;
    }
    else if(index > 0){//positive           
        while(currIndex != this.size){
            if(currIndex != index%size){
                currIndex++;
                currNode = currNode.getNext();
                nextNode = nextNode.getNext();
                prevNode = prevNode.getNext();                  
            }else{                              
                temp = currNode.getData();
                prevNode.setNext(currNode.getNext());
                nextNode.setPrev(currNode.getPrev());
                currNode = nextNode;
                size--;
                break;                                      
            }
        }   
    }
    else if(index < 0){//negative       
        while(currIndex != -this.size){
            if(currIndex != index%size){
                currIndex--;
                currNode = currNode.getPrev();
                prevNode = prevNode.getPrev();
                nextNode = nextNode.getPrev();
            }else{              
                temp = currNode.getData();
                prevNode.setNext(currNode.getNext());
                nextNode.setPrev(currNode.getPrev());
                currNode = prevNode;
                size--;
                break;                                      
            }
        }           
    }
    return temp;
} 
/**
 * Returns the size.
 * 
 * @return
 */
public int size(){
    return size;
}
@Override public String toString(){
    String str = "[";
    int index = 0;
    DoubleLinkedNode<E> curr = head;
    if(size == 0){
        return "There is no one here to kill.";         
    }else{      
        while (index <this.size) {
            str += curr.getData();  
            curr = curr.getNext();
            index++;
                if (index<this.size) {
                    str += ", ";
                }
        }
            str += "]";
    }
    return str;
  } 
@Override
public Iterator<E> iterator() {

    return new CircularDoubleIterator();
}   
// Iterator inner class begins
private class CircularDoubleIterator implements ListIterator<E> {

    private DoubleLinkedNode<E> nextItem;//reference to next item
    private int index = 0;
    private DoubleLinkedNode<E> lastReturned;// the last node to be returned by prev() or next()
                                            // reset to null after a remove() or add()

    @Override
    public E next() {
        if(!hasNext()){
            throw new NoSuchElementException("No such element.");
        }
        else{
                            nextItem = head; //edited 11Sept13
            lastReturned = nextItem.getNext();
            nextItem = nextItem.getNext();
                            head = nextItem; //edited 11Sept13
            index++;
            return lastReturned.getData();

        }
    }

    @Override
    public E previous() {
        if(!hasPrevious()){
            throw new NoSuchElementException("No such element.");
        }
        else{       

        index--;

        return ;
        }
    }

    @Override
    public int nextIndex() {
        return index;
    }

    @Override
    public int previousIndex() {
        return index-1;
    }
    @Override 
    public boolean hasNext() {  
        return size != 0;
    }

    @Override
    public boolean hasPrevious() {      
        return size!= 0;
    }
    @Override
    public void remove() {
    }

    @Override
    public void set(E theData) {
        if(lastReturned == null){
            throw new IllegalStateException();
        }
        else{
        }

    }

    @Override
    public void add(E theData) {
        if(size == 0){              
        }
        else if(size != 0){
        }

    }

}

//Iterator inner class ends
}

java 循环双链表列表迭代器

1条答案

相关问题

热门标签

最新问答