为什么会无限循环？ （爪哇）

Question

I am trying to make an add method for a linked list, but for some reason (that is not obvious to me, in fact I came here to get help finding the error) it goes into an infinite loop every time.

EDIT: I found the error, and I will keep my original code with a comment with the corrected code

public void insert(String majorName)
{
    MajorNode newNode = new MajorNode(majorName, 1);
    boolean inList = false;
    MajorNode current = first;

    if(isEmpty())
    {
        first = newNode;
                    // inList = true;
    }
    else
    {
        while(current.next != null)
        {
            if(current.majorName.equalsIgnoreCase(majorName))
            {
                current.frequency++;
                inList = true;
                break;
            }
            else
            {
                current = current.next;
            }
        }
    }

    if(!inList)
    {
        newNode.next = first;
        first = newNode;
    }
}

Here is my node class if it is needed:

public class MajorNode 
{
    public String majorName;
    public int frequency;
    public MajorNode next;

    public MajorNode(String majorName, int frequency)
    {
        this.majorName = majorName;
        this.frequency = frequency;
    }

    public String toString()
    {
        return majorName + " " + frequency;
    }
}

Answer 1

On the first call to insert() , one assumes isEmpty() returns true and consequently first is set to the newNode before newNode 's next field is set to the previous (null) value of first . Thus, when the list is non-empty, the loop iterates indefinitely on the last element in the list whose next field points to itself.

Out of curiosity, why are you trying to implement your own linked list functionality rather than build upon available packages (such as java.util.LinkedList<E> )?

Answer 2

When you create the first node you do this:

if(!inList)
{        
    newNode.next = first;        
    first = newNode;    
}

This points the first nodes next at itself... hence a loop

You should be leaving the newNode.next as null for the first node, so that when you insert the second item, you reach the end of the chain..

Answer 3

You will have an wrong frequency if you add a node which is similar to the last node of your List. Consider this situation (adding 2 similar nodes in the empty list)

1. You will add a node1 in a blank list. So first & current will point to node1. (but node1.next will be null)
2. If you add the same node (or a node with a same majorName ), you will reach to while loop (because List is not empty now). And also, you will not enter into a while loop as well. (as your current.next is still null) and you will end up with two noes with same majorName in your list.

I would suggest to use

while(current != null)

instead of

while(current.next != null)