Java排序链表打印两次

Question

我正在编写一个程序，该程序将接收一组数据，对其进行处理并将其排序在一个链表中。 我的问题是当我查看输出时，我的（myList.retrieve（0，20））; 第一次调用此方法时，它将打印两倍的内容。 删除2个元素后第二次输出正确。

public class Lab9Tester {
public static void main(String args[]){
    int testData[] = {5, 2, 7, 8, 3, 6, 10, 2, 6};
    int numberOfElementsDeleted = 0;
    SortedListOfInt myList = new SortedListOfInt();
    for (int i = 0; i < testData.length; i++){
        myList.addElement(testData[i]);
    }
    System.out.println("The values in the sorted list are given below");
    System.out.println(myList.retrieve(0, 20));
    System.out.println("The values in the sorted list between 4 and 7 are given below");
    System.out.println(myList.retrieve(4, 7));
    numberOfElementsDeleted = myList.deleteElement(6);
    System.out.println("Number of deleted elements  is " + numberOfElementsDeleted);
    System.out.println("The values in the sorted list after deleting all elements with value 6 are given below");
    System.out.println(myList.retrieve(0, 20));

}
}

我的测试程序，运行时预计输出：

The values in the sorted list are given below
2 2 3 5 6 6 7 8 10 
The values in the sorted list between 4 and 7 are given below
5 6 6 7 
Number of deleted elements  is 2
The values in the sorted list after deleting all elements with value 6 are given below
2 2 3 5 7 8 10

但是，第一行值打印两次

2 2 3 5 6 6 7 8 10 2 2 3 5 6 6 7 8 10 

我的其他课程如下：

public class SortedListOfInt {

ListGeneral myList = new ListGeneral();

private boolean needToRestart = true; 
private boolean restartFlag = false;

public void addElement(int x){

if(myList.listIsEmpty())
    {
        myList.addAfterCurrent(x);
        return;
    }


    if (myList.endOfList())
    {
        myList.addBeforeCurrent(x);
        myList.restart();
        return;
    }


    if (myList.currentValue() != null){
        int currentValue = (int) (myList.currentValue()); 
        if(currentValue >= x)
        {
            myList.addBeforeCurrent(x);
            myList.restart();
        }
        else if(currentValue < x)
        {
            myList.getNextNode(); 
            addElement(x); 
        }
    }
}


public String retrieve(int lowerLimit, int upperLimit)
{

    if(myList.listIsEmpty())
    {
        return ""; 
    }

    if(myList.endOfList() && needToRestart)
    {
        myList.restart();
        needToRestart = false;
        return "" + retrieve(lowerLimit, upperLimit);
    }
    if(myList.endOfList())
    {
        needToRestart = true; 
        return ""; 
    }

    int currentValue = (int) (myList.currentValue());

    if(currentValue >= lowerLimit &&  currentValue <= upperLimit)
    {

        String result =currentValue + " " ;
        myList.getNextNode(); 
        return result + retrieve(lowerLimit,upperLimit); 
    }
    else
    {
        myList.getNextNode(); 
        return retrieve(lowerLimit,upperLimit); 
    }
}

public int deleteElement(int x)
{
    repointToStart(); 

    int currentValue; 
    if(myList.endOfList())
    {
        restartFlag = false; 
        return 0; 
    }
    else
    {
        currentValue = (int) myList.currentValue(); 
        if(currentValue == x)
        {
            myList.removeCurrent();
            return deleteElement(x) + 1; 
        }
        else
        {
            myList.getNextNode();
            return deleteElement(x); 
        }
    }

}

private void repointToStart()
{
    if(restartFlag == false)
    {
        myList.restart();
        restartFlag = true; 
    }
}
}

教授给的：

public class ListGeneral {

protected Node firstNode; // firstNode can be used by this
// class and any of its subclass.
private Node currentNode, previousNode; // These are usable only
// within this class.

public ListGeneral(){ // Constructor creates an
    // empty list.
    currentNode = null;
    firstNode = null;
    previousNode = null;
}

/* 
 * The method addAfterCurrent adds a new node with value x 
 * after the current node.
 */
public void addAfterCurrent(Object x){
    if (firstNode == null){
        firstNode = new Node(x, null);
        currentNode = firstNode;
    }
    else{
        Node newNode = new Node(x, currentNode.getNext());
        currentNode.setNext(newNode);
        previousNode = currentNode;
        currentNode = newNode;
    }
}

/* 
 * The  method addBeforeCurrent adds a new node with value x 
 * before the current node.
 */
public void addBeforeCurrent(Object x){
    if (firstNode == null){
        firstNode = new Node(x, null);
        currentNode = firstNode;
    } 
    else {
        Node newNode = new Node(x, currentNode);
        if (previousNode != null) {
            previousNode.setNext(newNode);
        }
        else{
            firstNode = newNode;
        }
        currentNode = newNode;
    }
}

/* 
 * removeCurrent() deletes the current node. This is defined 
 * only if the list is not empty.
 */
public void removeCurrent(){
    Node temp;
    if (listIsEmpty() || endOfList()) return;
    temp = currentNode.getNext();
    /* 
     * if previousNode is null, firstNode is currentNode.                      
     */

    if (previousNode == null) {
        firstNode = temp;
    }
    else {
        previousNode.setNext(temp);
    }
    currentNode = currentNode.getNext();
}

/* 
 * listIsEmpty() is true if list is empty.
 * current() returns the current node.
 * restart() makes the the first node the current node. 
 */


public boolean listIsEmpty(){       
    return firstNode == null;
}

public Object currentValue(){
    return currentNode.getValue();
}

public void restart(){
    currentNode = firstNode;
    previousNode = null;
}

/*   endOfList() is true if current is not pointing to 
 * any node.
 */

public boolean endOfList(){
    return currentNode == null;
}

/* getNextNode makes the next node the current node. 
 * The method returns true if the operation was successful 
 * otherwise it returns false.
 */  
public boolean getNextNode(){
    if (currentNode == null) {
        return false;
    }
    else {
        previousNode = currentNode;
        currentNode = currentNode.getNext();
        return true;
    }
}   
/* 
 * method toString() returns the result of invoking toString() 
 * on all successive elements of the list.
 */     

public String toString(){
    String s = "";
    for(restart(); !endOfList(); getNextNode()){
        s += currentValue() + "\n";
    }
    return s;
}
}

以及给定的：

public class Node {
 private Object value;  // self-referential link.       
    private Node next;           

    public Node(Object value, Node nextNode)    // The constructor inserts the
    {                                            // arguments in the new object.
         this.value = value;
         this.next = nextNode;
    }
    public Object getValue(){
        return value;
    }

    public Node getNext(){
        return next;
    }

    public void setValue(Object value){
        this.value = value;
    }

    public void setNext(Node next){
        this.next = next;
    }
}

Answer 1

问题是您在SortedListofInt类中设置了needToRestart = true ，因此在执行初始检索时，它会调用两次，但设置了needToRestart = false 。 下次调用检索时，它仅打印一次。 最初，将needToRestart = false设置对我来说是正确的，并输出正确的输出。

这对我有用

public class SortedListOfInt {

ListGeneral myList = new ListGeneral();

private boolean needToRestart = false;
private boolean restartFlag = false; //the only change

...

}