LinkedList выпускает печать и удаление

Question

Итак, я спорил о том, стоит ли задавать и держать этот вопрос, чтобы посмотреть, смогу ли я получить некоторые ответы. Я исправил большинство ошибок, но у меня возникла огромная проблема с этим LinkedList. Прямо сейчас он продолжает удалять все мои узлы за самым первым и отображает все, кроме последнего узла. Я не могу понять, где мои проблемы. Я использовал отладку в jgrasp, чтобы помочь, но это не очень помогло

Я включил два файла, над которыми я работаю, для тех, кто хочет запустить его и посмотреть, что происходит сами

Файл ввода представляет собой текстовый файл, который будет иметь что-то похожее на это:

 1,10
 5,16
 2,7
 4,12
 3,19
 6,25
 9,13
 7,21
 8,4

Также потребуется int, который будет представлять время. Я использую 5

Это мой основной файл:

import java.util.*;
import java.io.*;

public class Test_RoundRobin{

public static void main(String args[]) throws IOException {
    LinkedList list=new LinkedList();
    String file=args[0];
    int cpuTime=Integer.parseInt(args[1]);

    Scanner fin=new Scanner(new FileReader(file));
    String pattern=",";
    fin.useDelimiter(pattern);
    while(fin.hasNext()){
        String s=fin.nextLine();
        String[] array=s.split(pattern);
        int pid=Integer.parseInt(array[0]);
        int time=Integer.parseInt(array[1]);
        list.add(pid, time);
    }
    fin.close();
    System.out.println(list);
    list.sortList();
    System.out.println(list);
    int count=1;
    while(list.size!=0){
        list.timeSlice(cpuTime);
        System.out.println("Run " + count + ": " + list);
        count++;
    }
    System.out.println(list);
}
}

Это файл LinkedList, который у меня есть: я использую фиктивный головной узел, и это круговой односвязный список.

public class LinkedList{
private class Node{
    private int pid;
    private int time;
    private Node next;

    public Node(int pid, int time){
        this.pid=pid;
        this.time=time;
    }
}//end Node

int size;
Node head;

public void add(int pid, int time) {
    Node curr=head;
    Node newNode=new Node(pid, time);
    //empty list
    if(head==null){
        head=newNode;
        newNode.next=head;
    }//end if
    else{
        while(curr.next!=head){
            curr=curr.next;
        }//end while
        curr.next=newNode;
        newNode.next=head;
    }//end else
    size++;
}//end add

public void delete(Node curr){
    if(size==0){
        return;
    }
    else if(head==curr){
        head=curr.next;
    }
    else{
        Node prev=find(curr);
        prev.next=curr.next;
    }
    size--;
}

public Node find(Node curr){
    for(Node prev=head; prev.next!=curr; prev=prev.next){
        return prev;
    }
    return curr;
}

public void sortList(){
    Node position;  // Position to fill...
    Node start;            // Where to start looking for the smallest...

    if(size>=0){
        for(position=head; position.next!=head; position=position.next){
            Node smallest=position;

            for(start=position.next; start!=head; start=start.next){
                if (start.pid<smallest.pid){
                    smallest = start;
                }//end if
            }//end for
            int tempPID=position.pid;
            int tempTime=position.time;
            position.pid=smallest.pid;
            position.time=smallest.time;
            smallest.pid=tempPID;
            smallest.time=tempTime;
        }//end for
    }//end if
}//end sortList

public void timeSlice(int cpuTime){
    for(Node curr=head; curr.next!=head; curr=curr.next){
        curr.time=curr.time-cpuTime;
        System.out.print("<" + curr.pid + ", " + curr.time +">" + " ");
        //if the time remaining <= 0 then remove the node
        if(curr.time<=0){
            System.out.println("Process " + curr.pid + " has finished, and is now being terminated");
            delete(curr);
        }
    }
}

public String toString(){
    String s="";
    for(Node curr=head; curr.next!=head; curr=curr.next)
        s=s+"<"+curr.pid+", "+curr.time+"> ";

    return s;
}
}

Заранее спасибо, это очень ценится.

Answer 1

Во-первых, вы не используете фиктивный узел, как вы сказали. Если список содержит только один узел, он фактически никогда не будет удален, так как head.next просто head снова. Это также переводит список в противоречивое состояние, в котором size 0, но он все еще имеет узел.

find даст неверные результаты, если вы ищете узел, которого нет в списке. Вы должны вероятно обнаружить это и выдать исключение.