Java链表指针混乱

Question

This Code below is from a java LinkedList implementation.The method adds a string element at an index point of the list and is taken from one of my cs books.

The linked list class has 2 global private variables

Node first;
Node last;

public void add(int index, String e) {
    if (index < 0 || index > size()) {
        String message = String.valueOf(index);
        throw new IndexOutOfBoundsException(message);
    }

    // Index is at least 0
    if (index == 0) {
        // New element goes at beginning
        first = new Node(e, first);
        System.out.println("ran");
        if (last == null)
            last = first;
        return;
    }

    // Set a reference pred to point to the node that
    // will be the predecessor of the new node
    Node pred = first;
    for (int k = 1; k <= index - 1; k++) {
        pred = pred.next;
    }

    // Splice in a node containing the new element
    pred.next = new Node(e, pred.next);
    System.out.println(toString());

    // Is there a new last element ?
    if (pred.next.next == null)
        System.out.println("ran");
        last = pred.next;
}

My question
I don't understand how Node first, last get updated in the condition below

Suppose you have a list that looks like ["1","2","3","7","4","5,"6"]

Then you add the the element "4" to index 3

So, the list looks likes ["1","2","3","4","7","4","5,"6"] , but looking at the code of the add method I don't know how the first or last node pointers gets updated. Because in my mind these are the only pieces of code that run because the index isn't 0 and the last doesn't change

EDIT

The Object Node first is used in the toString method(not shown) to traverse through the collection

    // Set a reference pred to point to the node that
    // will be the predecessor of the new node
    Node pred = first;
    for (int k = 1; k <= index - 1; k++) {
        pred = pred.next;
    }
    // Splice in a node containing the new element
    pred.next = new Node(e, pred.next);
    System.out.println(toString());

Answer 1

Before the add, the first element is "1" and the last element is "6".
After the add, the first element is "1" and the last element is "6".
You're right that the first and last dont change-- they don't need to, because you haven't changed the first or the last element.

Answer 2

I think you are getting bogged down by the way this linked list implementation works. The first and last pointers exist to just keep track of the start and end of the list. Hence, when you insert an element in the middle of the list, these pointers do not get updated, nor is there any need for such an update. But they do get updated should an insert land before the current head or after the current tail of the list. Here is the code which handles head inserts:

if (index == 0) {
    // New element goes at beginning
    first = new Node(e, first);
    System.out.println("ran");
    if (last == null)
        last = first;
    return;
}

The critical line here is actually this:

first = new Node(e, first);

The first pointer gets assigned to a new node, which in turn points to the old first node. Similarly, should an insert of a new node land at the end of the list, the following code will handle that:

if (pred.next.next == null) {
    System.out.println("ran");
    last = pred.next;
}

Here the last pointer is assigned to the new node which was inserted after the old last .

But other than these two edge cases, there is no need to update first and last with inserts.

Answer 3

If the index is 0, the node is added in the beginnng and the for loop doesn't work. If it is 1, the loop again doesn't execute and node is simply added to the list. However if it something else, then until the index-1 position is reached the loop shifts each element one step behind. Then the code just outside the loop (which slices in a node containing new element) inserts the element at index. If after the loop has executed, the index turns out to be the last one then the last node is updated.

Hope this helps!