Linked List Delete and insertAfter Method

I am having trouble with delete and insertAfter methods, the methods are to perform the action and return a boolean if the action was a success(true) or not(false). The InsertAfter method will insert a string but always in the same spot, and Delete method will always delete the same node.

private class StrNode {

        String data;
        StrNode next;
    }

    private StrNode head;   // the head of the singly-linked list.

    public StringList() {
        head = null;
    }

public void prepend(String s) {															
        var newNode = new StrNode();
        // TODO: Adds an item to the start of the list.		
        newNode.data = s;
        if(head == null) {
        	head = newNode;
        }
        else {
        newNode.next = head;
		head = newNode;
        }
        
    }

/**
     * Inserts an item after the first instance of a key if the key exists.
     *
     * @param s the item to insert
     * @param key the item in the list to insert after
     * @return whether the insertion was successful
     */
    public boolean insertAfter(String s, String key) {														
        // TODO: 	Inserts an item after the first instance of a key if the key exists.
    	var newNode = new StrNode();
    	StrNode current = head;
    	newNode.data = s;
    	
    	if(head == null) {
    		head = newNode;
    	}
    	else if(current == newNode.next){
    		current.next = newNode;
    		current = newNode;

    	}
    	else {
    		newNode.next = current.next;
    		current.next = newNode;
    	}
    	
    	
    	return false;
    }
    
    /**
     * Deletes the first instance of an item from the list.
     *
     * @param key the value of the item to delete from the list.
     * @return whether the deletion was successful.
     */
    public boolean delete(String key) {														
        // TODO:	Deletes the first instance of an item from the list.
    	StrNode current = head;
    	StrNode sucNode = current;
    	
    	if(current == null) {
    		sucNode = head.next;
    		head = sucNode;
    		return true;
    	}
    	else if(current.next != null) {
    		sucNode = current.next.next;
    		current.next = sucNode;
    		return true;
    	}

    	return false;
    }

the main method I am wanting to insert four after three which should be: three, two, four, one.
but I get: three, four, two, one

the delete method just deletes the four which should actually look like: three, four, two
but I get: three, two, one
main:

public static void main(String[] args) {
    	
    	StringList s = new StringList();
    	
    	s.prepend("one");
    	s.prepend("two");
    	s.prepend("three");
        System.out.println(s);
    	
    	s.insertAfter("four", "three");
    	System.out.println(s);
    	
    	System.out.println(s.delete("one"));
    	System.out.println(s);
        
        
    }

You asked about two methods:

insertAfter

Some issues:

• You don't use the argument key.
• In case head is null, you can never satisfy the condition that the node should be inserted after a node with a key, so in that case you should return false.
• current is initialised as head, so you are assigning the new node to head.next without checking the key matches...
• You always return false, never true

You should look for the given key by iterating over the list:

public boolean insertAfter(String s, String key) {
    // Inserts an item after the first instance of a key if the key exists.
    StrNode current = head;
    
    while (current != null) {
        if (current.data == key) { // found the insertion spot
            var newNode = new StrNode();
            newNode.data = s;
            newNode.next = current.next;
            current.next = newNode;
            return true;
        }
        current = current.next; // need to walk along the list
    }
    return false; // didn't find the key
}

delete

• You don't use the argument key.
• In case head (is current) is null, you can never satisfy the condition that the node to delete should have the given key, so in that case you should return false.
• In the other case, you are always deleting the second node without checking the key matches...

Corrected:

public boolean delete(String key) {                                                     
    // Deletes the first instance of an item from the list.
    StrNode current = head;
    if (head == null) return false;
    if (head.data == key) {
         head = head.next;
         return true;
    }

    while (current.next != null) {
        if (current.next.data == key) { // found it
            current.next = current.next.next; // delete it
            return true;
        }
        current = current.next; // need to walk along the list
    }
    return false; // not found
}

Remark about prepend:

You don't need the if statement. The code in the else block works fine when head is null, so your code can just be:

public void prepend(String s) { 
    // Adds an item to the start of the list. 
    StrNode node = new StrNode();
    node.data = s;
    node.next = head;
    head = node;
}