Help PLEASE with linked list. Inserting a string in the middle of

Question

I'm trying to insert new strings to a linked list but it seem i cant never insert. the following code has the instructions. What i'm I not doing right? If i try to use the code, the new strings don't go through
please help someone
// This method should insert a new node containing the string newString immediately after the first
    // occurrence of the string aString in the list. If aString is not in the list, the method should add a node
    // containing newString to the tail of the list.
    public void insertAfter(String newString, String aString)
        StringLLNode newNode = new StringLLNode();
        newNode.setData(newString);
        //Check if HeadNode == aString
        if (headNode.getData().equalsIgnoreCase(aString))
            headNode = newNode;
        //rest of the nodes
        StringLLNode currNode = headNode;
        while(currNode != null)
            if (currNode.getData().equalsIgnoreCase(aString))
                    newNode.setNext(currNode);
                    //System.out.println("It went THROUGH");
            currNode = currNode.getNext();
        //Last Node
        if (currNode != null)
            newNode.setNext(headNode);
    }

Answer 1

I have to agree with flounder, go grab a pen and paper and logically work thru the code snippet you posted.
public void insertAfter(String newString, String aString)
        StringLLNode newNode = new StringLLNode();
        newNode.setData(newString);
        //Check if HeadNode == aString
        if (headNode.getData().equalsIgnoreCase(aString))
            headNode = newNode;
        //rest of the nodes
        StringLLNode currNode = headNode;
        while(currNode != null)
            if (currNode.getData().equalsIgnoreCase(aString))
                    newNode.setNext(currNode);
                    //System.out.println("It went THROUGH");
            currNode = currNode.getNext();
        //Last Node
        if (currNode != null)
            newNode.setNext(headNode);
}Given a linked list [A-E] we have: A => B => C => D => E. Each Node is referencing the node to it's right, so A references B, D references E etc.
For example take aString = "A" and newString = "AB". Your code suggests the following:
1. Create new_node "AB"
2. if head[A] equals aString[A], TRUE
2.a head = new_ node
Now the resulting linkedlist is the following:
AB => Null
what happened to the rest of the list?
Now we go on to your updated example, we result in the following list:
A => AB => Null
hmm do you see a pattern here? when inserting a new node we are disregarding any reference to the tail of the list.
Extending on that idea we have the following pseudo code
1. if node to be inserted
1.a new_node.next = list_tail
1.b current_node.next = new_node
A => B => C => D => E, where newnode=AA
AA => B => C => D => E //using 1.a
A => AA => B => C => D => E //using 1.b
Mel